Foundation 102: Object Oriented Programming with Python

This advanced programming course teaches object-oriented programming through the development of interactive space-themed applications. Students learn to think in terms of objects, classes, and systems rather than simple procedures, preparing them for professional software development and advanced computer science concepts. By course completion, students will have built sophisticated simulations demonstrating mastery of encapsulation, inheritance, polymorphism, and system design.

What makes this course special: Object-oriented programming can be abstract and difficult to grasp—students often struggle to understand why they need classes when functions seem sufficient. This course makes OOP concrete and intuitive by building interactive systems where students can see their objects come to life, interact with each other, and demonstrate sophisticated behaviors through inheritance and polymorphism. The space academy theme provides perfect metaphors for understanding object relationships and system architecture.

Your Learning Journey

Starting with simple classes and objects, you'll progressively master encapsulation, inheritance, and polymorphism while building increasingly sophisticated interactive systems. Through projects like spacecraft simulations, fleet management systems, and space station operations, you develop both the technical skills and design thinking that characterize professional software engineering.

Each lesson introduces OOP concepts through hands-on development where abstract principles become concrete through working code. You'll learn to design class hierarchies, implement inheritance structures, and create polymorphic systems that demonstrate the power and elegance of object-oriented design. The progression moves from single-class programs to complex multi-class systems with dozens of interacting objects.

Perfect for: Students who have completed CS-101-INTRO or equivalent Python programming experience including variables, functions, loops, and conditionals.

Duration: 1 semester (12-16 sessions, adjustable)

Credits: 0.5 Computer Science Credit

Why This Course Matters

Real-World Applications

Game Development: Entities, components, game state management.
Business Software: Customer, order, inventory, and transaction systems.
Mobile Apps: View controllers, data models, service layers.
Web Applications: User accounts, content management, e-commerce systems.
Simulation Software: Physics engines, agent-based models, virtual environments.
Robotics: Sensor objects, actuator controllers, behavior systems.
Scientific Computing: Experiment objects, data structures, analysis pipelines.
OOP Powers Modern Software

Industry Standard: Most professional software uses OOP (Java, C++, Python, C#, Swift).
Scalability: OOP enables building large systems that remain manageable.
Code Reuse: Inheritance and composition reduce redundancy and improve maintenance.
Modeling Reality: Objects naturally represent real-world entities and their relationships.
Framework Foundation: Understanding OOP is essential for using modern frameworks and libraries.
Cognitive Development

Abstract Thinking: Recognize patterns and create generalizations.
Systems Design: Plan architecture before implementation.
Complexity Management: Break large problems into manageable, interacting components.
Relationships Building: Understand hierarchies, compositions, and interactions.
Solutions Refinement: Iterate on designs to improve structure and elegance.
Preparation for Advanced Studies

AP Computer Science A: Java-based OOP curriculum.
University CS Programs: Where OOP is foundational to most courses.
Software Engineering: Professional development practices and patterns.
Game Development: Where entity systems rely heavily on OOP.
AI and Machine Learning: Where frameworks are built on OOP principles.

Choose a pricing plan

Course curriculum

1

Section 1: Introduction
- Lesson 1: Welcome to Your Learning Journey
- Lesson 2: Programming as Philosophy
- Lesson 3: Why We Choose Thonny for Learning Python
- Lesson 4: Thonny Python IDE Installation Guide
2

Section 2: Digital Literacy
- Lesson 1: Introduction
- Lesson 2: File Management and Organization
- Lesson 3: Cross-Platform Computer Navigation
- Lesson 4: File Paths and Directory Structures
- Lesson 5: Productivity Keyboard Shortcuts
- Lesson 6: Practical Applications and Connections
- Lesson 7: Quick Reference Card
- Lesson 8: Your Foundation for Success
3

Section 3: Python Environment and OOP Foundations
- Lesson 1: Installing Python and Configuring Thonny IDE
- Lesson 2: Understanding Procedural vs Object-Oriented Programming
- Lesson 3: Creating Your First Simple Class
- Lesson 4: Instantiating Multiple Objects from a Class
- Lesson 5: Accessing Object Attributes and Calling Object Methods
- Quiz
4

Section 4: Class Attributes and Instance Methods
- Lesson 1: Designing Classes with Multiple Related Attributes
- Lesson 2: Implementing Instance Methods that Operate on Object Data
- Lesson 3: Understanding the Self Parameter
- Lesson 4: Creating Methods that Modify Object State
- Lesson 5: Method Coordination - Methods Calling Other Methods
- Quiz
5

Section 5: Data Protection and Encapsulation
- Lesson 1: Understanding Public vs Private Attributes
- Lesson 2: Implementing Private Attributes with Underscore Prefix
- Lesson 3: Creating Getter and Setter Methods for Controlled Access
- Lesson 4: Adding Validation Logic to Prevent Invalid Data States
- Lesson 5: Practicing Defensive Programming with Input Validation
- Quiz
6

Section 6: Property Decorators and Advanced Encapsulation
- Lesson 1: Understanding the @property Decorator
- Lesson 2: Implementing @property Decorators for Getter Methods
- Lesson 3: Creating @attribute.setter Decorators for Validation
- Lesson 4: Handling Invalid Data with Proper Error Messages
- Lesson 5: Combining Properties with Validation Logic for Robust Classes
- Quiz
7

Section 7: Interactive Object Systems
- Lesson 1: Building Interactive Command-Line Interfaces
- Lesson 2: Parsing User Input and Mapping to Object Methods
- Lesson 3: Implementing Menu Systems for Complex Object Interactions
- Lesson 4: Validating User Input Before Performing Operations
- Lesson 5: Creating Help Systems and User Documentation
- Quiz
8

Section 8: Complex Object Behaviors and State Management
- Lesson 1: Adding Positional and Status Attributes to Objects
- Lesson 2: Implementing Methods with Conditional Logic Based on State
- Lesson 3: Creating Object-to-Object Interaction Methods
- Lesson 4: Designing Methods that Verify Preconditions
- Lesson 5: Building Complex Scenarios with Multiple Object Interactions
- Quiz
9

Section 9: First Mid-Term
- First Mid-Term
10

Section 10: System Integration and Debugging Practices
- Lesson 1: Combining Classes, Methods, Properties, and Validation
- Lesson 2: Systematic Debugging Techniques for Complex Object Interactions
- Lesson 3: Using Print Statements and Thonny Debugger for Troubleshooting
- Lesson 4: Code Organization and Documentation Standards
- Lesson 5: Peer Code Review and Collaborative Debugging
- Quiz
11

Section 11: OOP Review and Enhancement Workshop
- Lesson 1: Reviewing Classes, Objects, Methods, Properties, and Encapsulation
- Lesson 2: Analyzing Existing Code for Improvement Opportunities
- Lesson 3: Refactoring Code to Improve Clarity and Maintainability
- Lesson 4: Adding New Features to Existing Object Systems
- Lesson 5: Systematic Code Review with Peers
- Quiz
12

Section 12: Inheritance Fundamentals and Base Classes
- Lesson 1: Understanding Inheritance Concepts and Real-World Models
- Lesson 2: Designing Base Classes with Common Attributes and Methods
- Lesson 3: Creating Derived Classes with Inheritance Syntax
- Lesson 4: Understanding the super() Function
- Lesson 5: Building Multi-Level Inheritance Hierarchies
- Quiz
13

Section 13: Method Overriding and Specialization
- Lesson 1: Understanding Method Overriding Concepts
- Lesson 2: Overriding Methods to Provide Specialized Behavior
- Lesson 3: Using super() to Extend Base Class Functionality
- Lesson 4: Creating Specialized Subclasses with Unique Attributes
- Lesson 5: Implementing Class-Specific Method Variations
- Quiz
14

Section 14: Inheritance Testing and Optimization
- Lesson 1: Developing Comprehensive Test Cases for Inheritance Hierarchies
- Lesson 2: Debugging Inheritance-Related Errors and Method Resolution Issues
- Lesson 3: Optimizing Class Structures for Code Reusability
- Lesson 4: Evaluating Inheritance Designs Using Code Review Practices
- Lesson 5: Refactoring Inheritance Hierarchies for Improved Maintainability
- Quiz
15

Section 15: Polymorphism and Duck Typing
- Lesson 1: Understanding Polymorphism Concepts and Benefits
- Lesson 2: Implementing Objects with Shared Interfaces Without Inheritance
- Lesson 3: Practicing Duck Typing Principles in Python
- Lesson 4: Creating Flexible Systems that Work with Diverse Object Types
- Lesson 5: Designing Polymorphic Methods that Handle Multiple Object Types
- Quiz
16

Section 16: Dynamic Object Interactions and Design Patterns
- Lesson 1: Building Systems Where Diverse Object Types Interact Polymorphically
- Lesson 2: Implementing Strategy Patterns Using Inheritance and Polymorphism
- Lesson 3: Creating Decision-Making Systems with Object-Oriented Design
- Lesson 4: Designing Flexible Interaction Frameworks
- Lesson 5: Testing Complex Object Interaction Scenarios
- Quiz
20

Section 20: Second Mid-Term
- Second Mid-Term
21

Section 21: Final Exam
- Final Exam

Foundation 102: Object Oriented Programming with Python

Your Learning Journey

Why This Course Matters

Real-World Applications

OOP Powers Modern Software

Cognitive Development

Preparation for Advanced Studies

Choose a pricing plan

Course curriculum