A self-paced, open course for learning object-oriented thinking using Python.
This course is designed for anyone to use at any time, with a flexible self-paced learning path.
Primary implementation language: Python
Primary lab environment: Google Colab
| Audience | Anyone who wants to learn object-oriented thinking using Python |
| Prerequisite | Basic Python; use Module 0 if needed |
| Format | Self-paced, browser-first, executable notebooks |
| Path | Module 0 prerequisite + Modules 1–16 |
| Checkpoints | Mid-Course Assessment + Final Project |
| Environment | Google Colab by default; local setup optional |
| Pace | No enrollment, fixed calendar, or institutional schedule |
- New learner: Start Here
- Want to track progress: Learner Progress Tracker
- Ready to run code: Open notebooks in Google Colab
- Need the course readings: Reading & Reference Access Guide
- Want the full pathway: Course Map
No enrollment or fixed calendar is required.
If this is your first visit:
- Open the Python Readiness Check.
- If the prerequisite feels comfortable, go directly to Module 1 and open its Colab notebook.
- If the prerequisite is difficult, complete Module 0 — Python Primer first.
- For each module, use this loop: README → notebook → exercises → quiz → assignment → mastery check.
You do not need to clone the repository to begin; Google Colab is the default zero-setup path.
This course is designed as OOP thinking using Python, not as a syntax-only Python course.
The learning storyline is:
Problem
↓
Objects
↓
Classes, State & Behavior
↓
Encapsulation
↓
Object Relationships
↓
Inheritance
↓
Polymorphism
↓
Advanced Object Concepts
↓
Exceptions & Contracts
↓
OO Analysis & Design
↓
Reusability & Patterns
↓
Complete OOP Solution
By the end of the course, learners should be able to:
- Explain object-oriented concepts and model a problem using objects, classes, identity, state, and behavior.
- Design collaborating objects using encapsulation, abstraction, responsibilities, and object relationships.
- Apply inheritance, overriding, polymorphism, dynamic binding, abstract classes, multiple inheritance, and mixins appropriately.
- Explain runtime object behavior including references, identity, lifecycle, operator overloading, genericity, modules, exceptions, assertions, and contracts.
- Perform object-oriented analysis, design, implementation, and testing (OOA → OOD → OOP → OOT).
- Build, test, demonstrate, and defend a complete object-oriented solution and recognize opportunities for code/design reuse.
See Course Map for the detailed module, learning-outcome, assessment, and source alignment.
For learners, the main path is:
- Start Here
- Open notebooks in Google Colab
- Self-Paced Learning Guide
- Learner Progress Tracker
- Self-Assessment Guide
- Mastery Checks with Worked Feedback
- Reading & Reference Access Guide
- Course Map
For facilitators, contributors, and course maintainers:
- Open Course Guide
- Instructor Guide
- Assessment Alignment
- Reference Map
- Source Boundary
- Grading Operational System
- Gradebook Quick Start
- Accessibility Guide
- Local Setup & Reproducibility
- Execution Audit
- Publication Checklist
- Release Notes
- Changelog
- Contributing
The numbered folders represent modules in a recommended order, not calendar weeks. Learners may move faster or slower as needed.
| Module | Topic |
|---|---|
| 0 | Python Primer / Prerequisite |
| 1 | Introduction to OOP & Thinking in Objects |
| 2 | Classes, Objects & Instances |
| 3 | Attributes, Methods, State & Behavior |
| 4 | Encapsulation & Abstraction |
| 5 | Object Relationships |
| 6 | Inheritance |
| 7 | Overriding, Polymorphism & Dynamic Binding |
| 8 | Mid-Course Assessment |
| 9 | Abstract Classes & Inheritance Structures |
| 10 | Multiple Inheritance & Mixins |
| 11 | Object Lifecycle, References & Object Identity |
| 12 | Operator Overloading, Genericity & Organizing Classes into Modules |
| 13 | Exception Handling & Assertions |
| 14 | OOP Analysis, Design, Class Diagram & Testing |
| 15 | Reusability, Design Patterns & OOP Case Study |
| 16 | Final Project / Final Assessment |
The repository includes a complete assessment model for learners or instructors who want structured evaluation.
| Component | Weight | Main repository evidence |
|---|---|---|
| Quiz / Concept Exercises | 15% | module quiz.md / exercises.md |
| Coding Labs | 20% | notebooks and assignment.md |
| Mid-Course Assessment | 20% | assessment package |
| Final Project | 35% | Final Project package |
| Demo / Code Explanation / Learning Evidence | 10% | rubric |
| Total | 100% |
Self-paced learners may instead use the quizzes, labs, and rubrics purely for self-assessment.
- Inggriani Liem. Diktat Kuliah Pemrograman Berorientasi Objek. Departemen Teknik Informatika ITB, 2003.
- OpenStax. Introduction to Python Programming. 2024.
The formal course scope is intentionally aligned to these two references.
The Diktat is used primarily for OOP concepts and terminology. OpenStax is used primarily for Python-facing implementation.
Learners can use the Reading & Reference Access Guide for the official free OpenStax access path and guidance on using the Diktat without making an unofficial copy a course dependency.
See the Reference Map for module-by-module source alignment and the Source Boundary for the rule that separates formal course concepts, minimal Python implementation bridges, and out-of-scope additions.
oop-course/
├── 00-python-primer/
├── week-01/
├── week-02/
├── ...
├── week-16/
├── assessments/
│ ├── midterm/
│ └── final-project/
├── templates/
├── scripts/
├── COURSE_MAP.md
├── REFERENCE_MAP.md
├── SOURCE_BOUNDARY.md
├── COLAB.md
├── CONTRIBUTING.md
├── OPEN_COURSE_GUIDE.md
├── SELF_PACED_GUIDE.md
├── INSTRUCTOR_GUIDE.md
├── EXECUTION_AUDIT.md
├── GRADING_SYSTEM.md
└── GRADEBOOK_GUIDE.md
Most instructional modules contain:
README.md
<module notebook>.ipynb
exercises.md
quiz.md
assignment.md
instructor-notes.md
The folder names remain week-01 through week-16 for repository stability, but they should be read as a recommended module sequence, not as fixed dates.
A recommended workflow is:
Read module README
↓
Run notebook examples
↓
Complete TODO cells
↓
Do selected exercises
↓
Take concept quiz
↓
Complete coding lab
↓
Attempt mastery checks
↓
Open worked feedback
↓
Write reflection
↓
Move to next module when ready
Use the Colab notebook index to launch the executable course notebooks directly in Google Colab. Save a personal copy, run the examples, complete the TODO cells, and compare your work against the stated requirements and rubrics.
For an optional local workflow, see Local Setup & Reproducibility.
If you use or adapt this course for teaching, training, or research, use the repository's citation metadata. GitHub can use this file to provide a Cite this repository action.
For adapted instructional material, preserve appropriate attribution and follow the license terms below.
See the Accessibility Guide for learner guidance and content-authoring rules. Essential course instructions should remain available as text, and new visuals should include equivalent text descriptions.
Instructional materials are licensed under Creative Commons Attribution 4.0 International (CC BY 4.0) and code/software portions are licensed under the MIT License, except where otherwise noted. See LICENSE.md.
This repository intentionally avoids turning the OOP course into a framework-development course.
Topics such as databases, REST APIs, GUIs, deployment, advanced testing frameworks, dependency-injection frameworks, and large architecture patterns are not required unless explicitly introduced as optional context.
The goal of this course is not merely to write classes. The goal is to learn how to model a problem as a set of meaningful objects that own state, perform behavior, collaborate, preserve their rules, and can be explained and tested.