Foothill CollegeApproved Course Outlines

Physical Sciences, Mathematics & Engineering Division
C S 21APROGRAMMING IN PYTHONSummer 2014
4 hours lecture, 3 hours laboratory.5 Units

Total Quarter Learning Hours: 84 (Total of All Lecture, Lecture/Lab, and Lab hours X 12)
 
 Lecture Hours: 4 Lab Hours: 3 Lecture/Lab:
 Note: If Lab hours are specified, see item 10. Lab Content below.

Repeatability -
Statement: Not Repeatable.

Status -
 Course Status: ActiveGrading: Letter Grade with P/NP option
 Degree Status: ApplicableCredit Status: Credit
 Degree or Certificate Requirement: AS Degree
 GE Status: Non-GE

Articulation Office Information -
 Transferability: BothValidation: 11/14/12;10/28/13

1. Description -
Introduction to the Python language and environment. Covers topics including object oriented programming, elementary data structures, modules, algorithms, recursion, data abstraction, code style, documentation, debugging techniques and testing.
Prerequisite: None
Co-requisite: None
Advisory: C S 1A and 2A or equivalent.

2. Course Objectives -
The student will be able to:
  1. Describe the basic elements of the Python language and the Python interpreter and discuss the differences between Python and other modern languages.
  2. Analyze and demonstrate the use of lists and tuples in Python.
  3. Describe and use Python dictionaries correctly and demonstrate the use of dictionary methods.
  4. Define, analyze and code the basic Python conditional and iterative control structures and explain how they can be nested and how exceptions can be used.
  5. Design, implement, test, and debug functions and methods that can be used in programs, and demonstrate the way parameters are passed in such functions and methods.
  6. Write classes to demonstrate the ideas of encapsulation, inheritance, interfaces and object oriented program design.
  7. Explain and demonstrate methods of error handling and Python exceptions.
  8. Demonstrate the understanding of “magic methods” through use of these in the context of a Python application.
  9. Use pre-written modules and learn the techniques necessary for creating modules.
  10. Write to and read from files using intermediate file I/O operations in a Python program.
  11. Use an existing library to implement a graphical user interface
  12. Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: string processing, numeric computation, simple I/O, arrays and the Python standard library.
  13. Solve problems that have origins in a variety of disciplines including math, science, the Internet and business.
3. Special Facilities and/or Equipment -
  1. Access to a computer laboratory with Python interpreters.
  2. Website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor). This applies to all sections, including on-campus (i.e., face-to-face) offerings.
  3. When taught via Foothill Global Access on the Internet, a fully functional and maintained course management system through which the instructor and students can interact.
  4. When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.

4. Course Content (Body of knowledge) -
  1. Introduction to Python
    1. Structure of a Python program
    2. The Python interactive interpreter
    3. Basic input and output
    4. Comparison of major languages
    5. Online Python resources
  2. Lists and Tuples
    1. Common sequence operations
    2. Lists
    3. Tuples
  3. Dictionaries
    1. Purpose
    2. Syntax
    3. Basic operations and methods
  4. Control Structures
    1. Selective and conditional statements
    2. Loop statements
    3. Nesting levels in control statements
    4. Handling exceptions
  5. Methods and Functional Programming
    1. Parameter passing
    2. Functional returns
    3. Variable scope
    4. Lambda functions
    5. Recursion
  6. Object-Oriented Programming - Classes and Methods
    1. Encapsulation of member data and methods
    2. Access modifiers and data privacy
    3. Encapsulation and properties
    4. Instance vs. static members
    5. Instance, class and static methods
    6. Object composition (the "has a" relationship)
    7. Inheritance (the “is a” relationship)
    8. Interfaces
    9. Object oriented design
  7. Error Reporting
    1. Raising exceptions
    2. Catching exceptions
    3. Multiple except clauses
    4. Catching two exceptions with one block
    5. Catching the object
    6. Implementing the non-exceptional situation
    7. The finally clause
    8. Exceptions and functions
  8. Magic Methods
    1. Constructors
    2. Item access
    3. Properties
    4. Iterators
    5. Generators
  9. Modules
    1. Module use
    2. Creating modules
    3. Exploring available Python modules
    4. The standard library
    5. Events and event driven programming using a predefined module.
  10. Files
    1. Opening files
    2. Basic file methods
    3. Iterating over file contents
    4. Accessing remote files with urllib
  11. Graphical User Interfaces
    1. Comparison of GUI toolkits
    2. GUI features
    3. Event handling
  12. Essential examples and Assignment Areas
    1. String/text processing
    2. Numeric computation
    3. User interaction through the console
    4. Lists and tuples
    5. Using Python-defined modules
    6. Creating and using a programmer-defined class
  13. Applications used throughout course in selected areas
    1. Math
    2. Physics
    3. Chemistry
    4. Biology
    5. Astronomy
    6. Business and finance
    7. Internet
5. Repeatability - Moved to header area.
 
6. Methods of Evaluation -
  1. Tests and quizzes
  2. Written laboratory assignments which include source code, sample runs and documentation.
  3. Final examination
7. Representative Text(s) -
Lutz, Mark. Learning Python. O'Reilly, 2013.

8. Disciplines -
Computer Science
 
9. Method of Instruction -
  1. Lectures which include motivation for syntax and use of the Python language and OOP concepts, example programs, and analysis of these programs.
  2. On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
    1. A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
    2. A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publicly with other class members.
  3. Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
  4. In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
  5. When course is taught fully on-line:
    1. Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
    2. Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.
 
10. Lab Content -
  1. Familiarization with the beginning-level lab environment
    1. Modify and customize the settings of an Integrated Development Environment (IDE).
    2. Use the IDE to create a new programming project.
    3. Organize projects within an IDE to make submitting labs and switching project environments an orderly process.
    4. Gain experience with the steps needed to edit a simple program.
    5. Modify IDE settings to produce an industry standard code style..
  2. Exploring the different data types using the compiler/IDE
    1. Gain experience in effectively using the IDE to create code with Python numeric and string types.
    2. Gain experience in effectively using the IDE to create code with simple data structures
    3. Use the IDE to assist in defining and using compound data types.
    4. Solve syntax and logic problems that arise from typical incorrect formulation of data types.
  3. Demonstrating user interaction (I/O) through the console and graphical interface
    1. Play the role of user and programmer, alternately, to establish a user-interaction plan for a program.
    2. Evaluate and comment on other students' user-interaction plan.
    3. Change modes from source code design (editing mode) to end-user interaction (run mode) in the IDE in order to perform Q/A on the program.
    4. Fix poor interaction behavior by adjusting source code and rerunning program until a satisfactory result is achieved.
  4. Building a program that demonstrates “intelligence” though a combination of control statements
    1. Become familiar with selection, loop and nesting to imbue a program with correct logic behavior.
    2. Use structured programming to make control structures maintainable.
    3. Run the program multiple times to verify that its control statements produce the correct behavior or output under any scenario.
    4. Fix incorrect logic behavior by adjusting control structures and rerunning program until a satisfactory result is achieved.
  5. Incorporating functions and class methods in programming projects
    1. Gain experience in writing a function/method.
    2. Use a previously written function or method in a client program.
    3. Refine methods/functions by adding or changing their definitions and observe the result.
    4. Deduce the impact of a function's or method's design on the programs that invoke it.
  6. Building a program around object-oriented techniques
    1. Use previously written classes to instantiate objects in program.
    2. Use the IDE to assist in the creation of a programmer-defined class.
    3. Demonstrate the correct choice of class members and methods for each class used.
    4. Import and use Python modules in conjunction with user written code.
  7. Exploring Lists, Tuples and Dictionaries
    1. Understand the proper use of lists, tuples and dictionaries.
    2. Incorporate a of lists, tuple or dictionary into a program to facilitate the solution of an assigned problem.
    3. Investigate use of sequence operations to shorten and clarify the logic in programs.
    4. Use debugging techniques to solve problems that arise during the testing of a program.
  8. Devising and utilizing algorithms
    1. Write a program that uses a combination of techniques such as looping, lists, logic and user I/O, all encapsulated in a coherent algorithm.
    2. Test the algorithm by running the program multiple times giving it different initial values or inputs.
    3. Implement a sorting or simple searching algorithm using arrays.
    4. Transcribe an abstract algorithm into a concrete program that is written and tested using the IDE and submitted online for evaluation.
  9. Organizing and debugging multi-class projects
    1. Demonstrate the ability to debug programs that contain multiple classes.
    2. Distinguish between interface and implementation in projects by creating classes that are independent of I/O modality.
    3. Write individual component classes that are independent of client use and can serve several client programs.
    4. Incorporate symbolic constants, statics and instance members into classes in a way that demonstrates a mature understanding of object-oriented programming (OOP) in a lab project.
    5. Debug a multi-class project to produce a working program.
  10. Building a program that uses class inheritance and interfaces to demonstrate how re-use is handled in OOP.
    1. Create a project that contains at least one class intended to be used as a base class.
    2. Derive (sub-class) one or more classes from the base class or classes.
    3. Create and use an interface to solve a given problem.
  11. Exceptions and File I/O in Programming
    1. Write a class that has methods which use exception handling to report errors to the client.
    2. Write a test client that uses try/catch blocks to detect exceptions.
    3. Implement an algorithm or simulation that reads from and/or writes to files rather than the user screen
    4. Demonstrate various ways errors are handled and reported besides exceptions.
 
11. Honors Description - No longer used. Integrated into main description section.
 
12. Types and/or Examples of Required Reading, Writing and Outside of Class Assignments -
  1. Reading
    1. Textbook assigned reading averaging 30 pages per week.
    2. Reading the supplied handouts and modules averaging 10 pages per week.
    3. Reading on-line resources as directed by instructor though links pertinent to programming.
    4. Reading library and reference material directed by instructor through course handouts.
  2. Writing
    1. Writing technical prose documentation that supports and describes the programs that are submitted for grades.
13. Need/Justification -
This course is a restricted support course for the A.S. degree in Computer Science.


Course status: Active
Last updated: 2014-06-18 17:08:13


Foothill CollegeApproved Course Outlines