Online Course
Platform —
One Interface, Many Lessons.

Glossary

A 30-Second Experiment: Watch Abstractness Disappear

This tiny program uses shapes instead of lessons so you can focus on one mechanism: Python's list of still-unimplemented methods. We inherit twice and print that list at each stage.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        ...

    @abstractmethod
    def name(self):
        ...

print(type(Shape))
print(sorted(Shape.__abstractmethods__))

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

print(sorted(Square.__abstractmethods__))
try:
    Square(3)
except TypeError as err:
    print("TypeError:", err)

class FullSquare(Square):
    def name(self):
        return "square"

print(sorted(FullSquare.__abstractmethods__))
sq = FullSquare(3)
print(sq.name(), sq.area())

Error Message Decoder

You will meet these errors while experimenting. Each one points at a specific design mistake.

Who Knows What

The design has three layers. The abstract contract sits in the middle; the course engine depends only on it, and concrete lessons implement it.

Completion Means Different Things

"Done" is not one rule. Each lesson type defines it for itself — that is the polymorphic part.

Step 1 — The Abstract Content Contract

We start with the contract. Content cannot be instantiated; every lesson must supply kind, render(), and is_complete().

from abc import ABC, abstractmethod

class Content(ABC):
    def __init__(self, title: str, minutes: int):
        self.title = title
        self.minutes = minutes

    @property
    @abstractmethod
    def kind(self) -> str:
        ...

    @abstractmethod
    def render(self) -> str:
        ...

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

    def label(self) -> str:
        return f"[{self.kind}] {self.title} ({self.minutes} min)"

class Video(Content):
    def __init__(self, title, minutes, url):
        super().__init__(title, minutes)
        self.url = url

    @property
    def kind(self):
        return "Video"

    def render(self):
        return f"▶ Streaming {self.url}"

    def is_complete(self, progress):
        return progress.get("watched_pct", 0) >= 90

class Article(Content):
    def __init__(self, title, minutes, words):
        super().__init__(title, minutes)
        self.words = words

    @property
    def kind(self):
        return "Article"

    def render(self):
        return f"📄 Showing {self.words} words"

    def is_complete(self, progress):
        return progress.get("scrolled_pct", 0) >= 100

class Quiz(Content):
    def __init__(self, title, minutes, questions, pass_mark=0.7):
        super().__init__(title, minutes)
        self.questions = questions
        self.pass_mark = pass_mark

    @property
    def kind(self):
        return "Quiz"

    def render(self):
        return f"❓ Asking {len(self.questions)} questions"

    def is_complete(self, progress):
        return progress.get("score", 0) >= self.pass_mark

try:
    Content("Nope", 1)
except TypeError as err:
    print("Blocked:", err)

lessons = [
    Video("Welcome", 6, "welcome.mp4"),
    Article("Why Interfaces Matter", 8, 1200),
    Quiz("Checkpoint", 5, ["Q1", "Q2", "Q3"]),
]
for item in lessons:
    print(item.label())
    print("   ", item.render())

🔍 Step 1 Deep Dive — How Python Enforces the Contract

Before reading the code line by line, learn when Python checks things. There are two separate moments, and mixing them up is the most common source of confusion with abstract classes.

📖 Line-by-line walkthrough

1. from abc import ABC, abstractmethod — ABC is a ready-made base class whose metaclass is ABCMeta. abstractmethod is the decorator that flags a method as "must be overridden".
2. class Content(ABC): — inheriting from ABC is what switches on the abstract-class machinery. Without it, @abstractmethod does nothing at all.
3. __init__(self, title, minutes) — shared state lives here once. Every lesson has a title and a duration, so subclasses reuse this through super().__init__(...) instead of copying it.
4. @property above @abstractmethod on kind — this declares an abstract read-only attribute. Callers write item.kind with no parentheses. The body is ... (Ellipsis), a placeholder meaning "intentionally empty". Decorators apply bottom-up: abstractmethod first, then property wraps the result.
5. Abstract render() and is_complete(progress) — the names and parameters are the contract. Python only checks that a method with that name exists; it does not verify the parameters match. Keeping signatures consistent is your discipline, which is why type hints and tests matter.
6. label() (concrete) — a normal method that every subclass inherits. Inside it, self.kind is looked up at runtime on the real object, so a Video prints [Video] and a Quiz prints [Quiz]. This is the Template Method idea: fixed skeleton in the base, variable details in subclasses.
7. class Video(Content) and super().__init__(title, minutes) — Video needs an extra url, so it has its own __init__. It must call the parent's first, otherwise self.title and self.minutes are never set.
8. kind returns a constant — because it is a property with no setter, video.kind = "X" raises AttributeError. The lesson's type cannot be changed by accident.
9. progress.get("watched_pct", 0) >= 90 — .get(key, default) returns 0 when nothing has been recorded yet. Writing progress["watched_pct"] would crash with KeyError for a brand-new learner.
10. pass_mark=0.7 in Quiz — a fraction from 0 to 1. The score stored in progress must use the same scale (0.8 means 80%). Mixing 0.8 with 80 is a classic unit bug.
11. try: Content("Nope", 1) — a live proof that the class is abstract. We catch the TypeError and print it so you can read the message Python gives.
12. The final for loop — it calls label() and render() on three different types with identical code. No if, no isinstance. That is polymorphism.

The first line's wording depends on your Python version (older versions say "with abstract methods is_complete, kind, render"). The method names are listed alphabetically, not in the order you wrote them.

⚠️ Common mistakes

🧪 Try it yourself

Step 2 — The Course Engine

The Course class stores lessons and learner progress. Notice that it never checks a lesson's type.

from abc import ABC, abstractmethod

class Content(ABC):
    def __init__(self, title):
        self.title = title

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

class Video(Content):
    def is_complete(self, progress):
        return progress.get("watched_pct", 0) >= 90

class Article(Content):
    def is_complete(self, progress):
        return progress.get("scrolled_pct", 0) >= 100

class Quiz(Content):
    def is_complete(self, progress):
        return progress.get("score", 0) >= 0.7

class Course:
    def __init__(self, name):
        self.name = name
        self._lessons = []
        self._progress = {}

    def add(self, lesson: Content):
        self._lessons.append(lesson)
        return self

    def record(self, title, **data):
        self._progress.setdefault(title, {}).update(data)

    def status(self):
        return [(l.title, l.is_complete(self._progress.get(l.title, {}))) for l in self._lessons]

    def percent_complete(self):
        done = sum(1 for _, ok in self.status() if ok)
        return round(100 * done / len(self._lessons))

course = Course("Python OOP Foundations")
course.add(Video("Welcome")).add(Article("Interfaces")).add(Quiz("Checkpoint"))

course.record("Welcome", watched_pct=95)
course.record("Interfaces", scrolled_pct=60)
course.record("Checkpoint", score=0.8)

for title, ok in course.status():
    print("✓" if ok else "·", title)
print(f"Progress: {course.percent_complete()}%")

🔍 Step 2 Deep Dive — Following One Call Through the Engine

The best way to understand polymorphism is to follow a single call and watch where Python chooses the code to run. Here is everything that happens when we call course.percent_complete().

📖 Line-by-line walkthrough

1. The compact Content at the top — this example repeats a trimmed contract so it runs on its own. It keeps only title and is_complete, because those are the only parts Course needs. In a real project you would import the full class from one module.
2. Three tiny subclasses — each holds only its completion rule. They inherit __init__ from Content, so Video("Welcome") works without writing a constructor.
3. self._lessons = [] and self._progress = {} — the leading underscore is a convention meaning "internal; use the methods, not these attributes". Lessons are stored in a list because order matters; progress is a dict keyed by lesson title for quick lookup.
4. add(self, lesson: Content) — the type hint says "anything that is a Content". It documents the dependency on the abstraction. Returning self lets you chain: course.add(a).add(b).add(c).
5. record(self, title, **data) — **data collects keyword arguments into a dict, so record("Welcome", watched_pct=95) gives data = {"watched_pct": 95}. setdefault(title, {}) returns the existing dict for that title or creates an empty one, and .update(data) merges the new values in.
6. status() list comprehension — builds (title, done) tuples. Notice the engine never asks what kind of lesson it has. There is no isinstance anywhere.
7. percent_complete() — for _, ok in self.status() unpacks each tuple and ignores the title with _. sum(1 for ... if ok) counts the finished lessons.
8. The fluent course.add(...).add(...).add(...) — builds the course in one expression, thanks to return self.
9. Three record calls — simulate a learner: watched 95% of the video, scrolled 60% of the article, scored 80% on the quiz.
10. The printing loop — shows ✓ for done and · for not done using a conditional expression: "✓" if ok else "·".

⚠️ Common mistakes and design weak spots

🧪 Try it yourself

Step 3 — Add a New Lesson Type (Zero Changes to Course)

Now the payoff. We add a CodeExercise lesson and a small registry that builds lessons from plain data, as if loaded from a JSON file or database.

from abc import ABC, abstractmethod

class Content(ABC):
    registry = {}

    def __init__(self, title):
        self.title = title

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Content.registry[cls.__name__.lower()] = cls

    @abstractmethod
    def render(self) -> str:
        ...

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

    @classmethod
    def from_dict(cls, data: dict):
        kind = data["type"]
        if kind not in cls.registry:
            raise ValueError(f"Unknown lesson type: {kind}")
        return cls.registry[kind](data["title"])

class Video(Content):
    def render(self):
        return "▶ Streaming video"
    def is_complete(self, progress):
        return progress.get("watched_pct", 0) >= 90

class CodeExercise(Content):
    def render(self):
        return "💻 Opening code editor"
    def is_complete(self, progress):
        return progress.get("tests_passed", 0) == progress.get("tests_total", -1)

catalog = [
    {"type": "video", "title": "Welcome"},
    {"type": "codeexercise", "title": "Write your first ABC"},
]
lessons = [Content.from_dict(d) for d in catalog]
for lesson in lessons:
    print(type(lesson).__name__, "→", lesson.render())

print(lessons[1].is_complete({"tests_passed": 5, "tests_total": 5}))

try:
    Content.from_dict({"type": "hologram", "title": "Future"})
except ValueError as err:
    print("Error:", err)

🔍 Step 3 Deep Dive — Self-Registering Classes

This step uses two features that look magical until you see the timeline: __init_subclass__ and class methods. Here is what happens as Python reads the file from top to bottom.

📖 Line-by-line walkthrough

1. registry = {} inside Content — a class attribute: one dict shared by Content and every subclass. That sharing is exactly what we want here, because all subclasses must write into the same table.
2. def __init_subclass__(cls, **kwargs) — a special hook Python calls every time someone subclasses Content. cls is the new subclass (for example Video), not Content. It is an implicit class method, so no decorator is needed.
3. super().__init_subclass__(**kwargs) — passes any extra arguments up the inheritance chain. It is good manners (cooperative inheritance): if another base class also uses this hook, it still works.
4. Content.registry[cls.__name__.lower()] = cls — cls.__name__ is the text "Video"; .lower() makes it "video". We store the class itself (not an instance) as the value, because classes are ordinary objects you can keep in a dict and call later.
5. Abstract render and is_complete — the contract is unchanged. The registry adds a way to find classes; it does not replace the contract.
6. @classmethod def from_dict(cls, data) — an alternative constructor. A class method receives the class as its first argument, so it can be called as Content.from_dict(...) without creating an instance first.
7. if kind not in cls.registry: raise ValueError(...) — fail loudly with a clear message. Returning None instead would let a bad lesson slip into a course and cause a confusing error much later.
8. return cls.registry[kind](data["title"]) — read it in two halves: cls.registry[kind] fetches a class; (data["title"]) calls it like any constructor. Two pairs of brackets, two different jobs.
9. CodeExercise.is_complete — uses progress.get("tests_total", -1). The default of -1 can never equal a real count of passed tests, so a lesson with no recorded results is never accidentally "complete" (0 == 0 would be a bug).
10. The catalog list of dicts — stands in for data loaded from JSON or a database. Only strings, no Python classes, so storage stays independent of code.
11. The final try/except — shows the failure path: an unknown type produces a readable ValueError.

⚠️ Common mistakes

🧪 Try it yourself

Step 4 — Certificates via the Strategy Pattern

Different courses award certificates differently. Rather than hard-coding one rule, abstract it behind a CompletionPolicy.

from abc import ABC, abstractmethod

class CompletionPolicy(ABC):
    @property
    @abstractmethod
    def name(self) -> str:
        ...

    @abstractmethod
    def earns_certificate(self, results: dict) -> bool:
        ...

class AllLessons(CompletionPolicy):
    @property
    def name(self):
        return "Finish every lesson"

    def earns_certificate(self, results):
        return all(results.values())

class Threshold(CompletionPolicy):
    def __init__(self, percent):
        self.percent = percent

    @property
    def name(self):
        return f"Finish at least {self.percent}%"

    def earns_certificate(self, results):
        done = sum(results.values())
        return 100 * done / len(results) >= self.percent

class MustPassQuizzes(CompletionPolicy):
    @property
    def name(self):
        return "Pass every quiz"

    def earns_certificate(self, results):
        return all(ok for title, ok in results.items() if title.startswith("Quiz:"))

results = {"Video: Welcome": True, "Article: Interfaces": False, "Quiz: Checkpoint": True}

for policy in [AllLessons(), Threshold(60), MustPassQuizzes()]:
    verdict = "🎓 Certificate" if policy.earns_certificate(results) else "✗ Not yet"
    print(f"{policy.name:<24} {verdict}")

🔍 Step 4 Deep Dive — The Strategy Pattern, Role by Role

Strategy has three participants. Naming them makes the pattern easy to spot in other codebases.

📖 Line-by-line walkthrough

1. CompletionPolicy with an abstract name property — lets any policy describe itself, which is handy for dashboards and logs ("Why didn't I get my certificate?").
2. earns_certificate(self, results) — the policy receives a simple dict of {title: finished?}, not the lesson objects. Keeping the input small makes strategies trivial to test and keeps them independent from Content.
3. AllLessons: all(results.values()) — all() returns True only if every item is true, and it stops at the first False, so it is also efficient.
4. Threshold.__init__(self, percent) — strategies can carry settings. Threshold(60) and Threshold(80) are two different rules created from one class.
5. sum(results.values()) — in Python True equals 1 and False equals 0, so summing booleans counts the trues. Then 100 * done / len(results) uses true division and gives 66.666… for 2 of 3.
6. f"Finish at least {self.percent}%" — the name is built from configuration, so each Threshold describes itself accurately.
7. MustPassQuizzes: the generator expression — ok for title, ok in results.items() if title.startswith("Quiz:") keeps only quiz entries and yields their results; all(...) then requires every one to be true. It relies on a title prefix, a weakness discussed below.
8. The results dict — in a real system you would build this from course.status() in Step 2.
9. for policy in [AllLessons(), Threshold(60), MustPassQuizzes()] — a list holding three different classes. They are interchangeable because all share the interface — the same reason a Course can hold three lesson types.
10. f"{policy.name:<24} {verdict}" — the :<24 format spec left-aligns the name inside 24 characters so the verdicts line up in a column.

Same learner, same results, three different outcomes — only the strategy changed.

⚠️ Common mistakes and design weak spots

🧪 Try it yourself

Task: create Assignment(title, max_points) that extends Content. Its kind is "Assignment", render() returns a message mentioning the points, and it is complete only when the progress dict contains submitted: True.

from abc import ABC, abstractmethod

class Content(ABC):
    def __init__(self, title):
        self.title = title

    @property
    @abstractmethod
    def kind(self) -> str:
        ...

    @abstractmethod
    def render(self) -> str:
        ...

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

class Assignment(Content):
    def __init__(self, title, max_points):
        super().__init__(title)
        self.max_points = max_points

    @property
    def kind(self):
        return "Assignment"

    def render(self):
        return f"📝 Submit your work ({self.max_points} points)"

    def is_complete(self, progress):
        return progress.get("submitted", False) is True

task = Assignment("Build a Shape ABC", 20)
print(task.kind, "|", task.render())
print(task.is_complete({}))
print(task.is_complete({"submitted": True}))

Task: add next_lesson() to Course. It returns the title of the first lesson that is not yet complete, or None when everything is done.

from abc import ABC, abstractmethod

class Content(ABC):
    def __init__(self, title):
        self.title = title

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

class Video(Content):
    def is_complete(self, progress):
        return progress.get("watched_pct", 0) >= 90

class Course:
    def __init__(self):
        self._lessons = []
        self._progress = {}

    def add(self, lesson):
        self._lessons.append(lesson)
        return self

    def record(self, title, **data):
        self._progress.setdefault(title, {}).update(data)

    def next_lesson(self):
        for lesson in self._lessons:
            if not lesson.is_complete(self._progress.get(lesson.title, {})):
                return lesson.title
        return None

course = Course().add(Video("One")).add(Video("Two")).add(Video("Three"))
course.record("One", watched_pct=100)
print(course.next_lesson())
course.record("Two", watched_pct=95)
course.record("Three", watched_pct=92)
print(course.next_lesson())

Task: write a FakeContent subclass whose completion is just a stored True/False, then use assert to test a percent_complete function — including the empty-course case — without any videos or browsers.

from abc import ABC, abstractmethod

class Content(ABC):
    def __init__(self, title):
        self.title = title

    @abstractmethod
    def is_complete(self, progress: dict) -> bool:
        ...

class FakeContent(Content):
    def __init__(self, title, done):
        super().__init__(title)
        self.done = done

    def is_complete(self, progress):
        return self.done

def percent_complete(lessons):
    if not lessons:
        return 0
    done = sum(1 for lesson in lessons if lesson.is_complete({}))
    return round(100 * done / len(lessons))

assert percent_complete([]) == 0
assert percent_complete([FakeContent("a", True), FakeContent("b", False)]) == 50
assert percent_complete([FakeContent("a", True)] * 3) == 100
print("All tests passed")

Task: write WeightedPolicy(percent, quiz_weight=2) as a new CompletionPolicy. Quizzes count quiz_weight times; other lessons count once. A certificate is earned when the weighted percentage reaches percent. For the sample results, weights are 1 + 1 + 2 = 4 and the learner earned 3.

from abc import ABC, abstractmethod

class CompletionPolicy(ABC):
    @abstractmethod
    def earns_certificate(self, results: dict) -> bool:
        ...

class WeightedPolicy(CompletionPolicy):
    def __init__(self, percent, quiz_weight=2):
        self.percent = percent
        self.quiz_weight = quiz_weight

    def earns_certificate(self, results):
        if not results:
            return False
        total = earned = 0
        for title, ok in results.items():
            weight = self.quiz_weight if title.startswith("Quiz:") else 1
            total += weight
            if ok:
                earned += weight
        return 100 * earned / total >= self.percent

results = {"Video: Welcome": True, "Article: Interfaces": False, "Quiz: Checkpoint": True}
print(WeightedPolicy(70).earns_certificate(results))
print(WeightedPolicy(80).earns_certificate(results))

Task: improve the Step 3 registry so a subclass can choose its own type name: class CodeExercise(Content, type_name="code"). When no name is given, fall back to the lowercase class name.

from abc import ABC, abstractmethod

class Content(ABC):
    registry = {}

    def __init__(self, title):
        self.title = title

    def __init_subclass__(cls, type_name=None, **kwargs):
        super().__init_subclass__(**kwargs)
        Content.registry[type_name or cls.__name__.lower()] = cls

    @abstractmethod
    def render(self) -> str:
        ...

class Video(Content):
    def render(self):
        return "▶ video"

class CodeExercise(Content, type_name="code"):
    def render(self):
        return "💻 editor"

print(sorted(Content.registry))
print(Content.registry["code"]("Hello").render())

Task: the program below is broken. Run it, read the error, fix it, run again, and keep going until render() works. Then add a working is_complete that does not crash when the learner has no recorded progress. Expect more than one bug.

from abc import ABC, abstractmethod

class Lesson(ABC):
    def __init__(self, title):
        self.title = title

    @abstractmethod
    def render(self):
        ...

    @abstractmethod
    def is_complete(self, progress):
        ...

class Reading(Lesson):
    def __init__(self, title, pages):
        self.pages = pages

    def render(self):
        return f"Reading {self.title}: {self.pages} pages"

lesson = Reading("Intro", 12)
print(lesson.render())

from abc import ABC, abstractmethod

class Lesson(ABC):
    def __init__(self, title):
        self.title = title

    @abstractmethod
    def render(self):
        ...

    @abstractmethod
    def is_complete(self, progress):
        ...

class Reading(Lesson):
    def __init__(self, title, pages):
        super().__init__(title)
        self.pages = pages

    def render(self):
        return f"Reading {self.title}: {self.pages} pages"

    def is_complete(self, progress):
        return progress.get("pages_read", 0) >= self.pages

lesson = Reading("Intro", 12)
print(lesson.render())
print(lesson.is_complete({}))
print(lesson.is_complete({"pages_read": 12}))

Lessons From This Project

Key Takeaways

• The engine depends on the abstraction — Course knows Content, never Video.
• Behavior belongs in the subclass — each lesson defines its own rendering and completion.
• Registries make extension cheap — new types register themselves on definition.
• Strategies capture business rules — certificate logic swaps without touching the course.
• Keep contracts small — fewer abstract members mean easier implementations.