Understand how Python actually constructs objects - the difference between __new__ and __init__, two-phase creation, mutable default argument traps, super().__init__() in inheritance chains, and factory patterns with classmethods.
Master Python's ABC system - abc.ABC, @abstractmethod, ABCMeta, virtual subclasses via register(), collections.abc built-in protocols, using ABCs in type hints, and the ABCs vs typing.Protocol trade-off.
Understand Python classes and objects at the engineering level - class vs instance namespace, attribute resolution, type as metaclass, class body execution, and the shared mutable attribute trap.
Master the is-a vs has-a distinction, understand why "favour composition over inheritance" exists, implement the delegation pattern, use mixins, refactor inheritance to composition, and apply dependency injection with typing.Protocol for structural typing.
Master Python's @dataclass decorator at engineering depth - what it generates, field() and default_factory, frozen=True for immutability, __post_init__ for validation, ClassVar vs InitVar, inheritance with dataclasses, ordering, and production patterns in FastAPI and config systems.
Master the most important GoF design patterns in idiomatic Python - Singleton, Factory, Abstract Factory, Strategy, Observer, Decorator, Registry, and Builder. For each - GoF intent, Pythonic implementation, and real framework usage.
Master Python's dunder (double-underscore) method system - comparison protocols, arithmetic operators, container protocols, context managers, callable objects, and attribute access hooks. Learn how Python's syntax maps to method calls.
Master Python's encapsulation model - single vs double underscore conventions, name mangling mechanics, @property for controlled access, validation in setters, __slots__, and the descriptor protocol that powers @property, @classmethod, and @staticmethod internally.
Master Python inheritance at the engineering level - what inheritance actually does to namespaces, single and multiple inheritance, the MRO algorithm, cooperative super(), the fragile base class problem, isinstance/issubclass, and when inheritance is correct.
Master Python's object model at engineering depth - classes, instances, dunder methods, encapsulation, inheritance, MRO, composition, abstract base classes, dataclasses, SOLID principles, and production design patterns.
Understand Python's Method Resolution Order at engineering depth - the diamond problem, C3 linearisation step by step, how super() traverses the MRO (not just "calls parent"), mixin patterns that depend on MRO, Django/Flask examples, and MRO failure cases.
Four hands-on OOP engineering projects for the Python Intermediate module. Build real systems using classes, inheritance, ABCs, dunders, and composition.
Build a banking system using Python OOP. Covers inheritance, @property validation, @classmethod factory methods, __repr__, overdraft protection, and transaction history.
Build a library management system using Python OOP. Covers __repr__, __eq__, __hash__, Abstract Base Classes, checkout systems with date tracking, overdue detection, and fine calculation.
Build a working chess engine in Python using ABCs, dunders, dataclasses, and composition. Covers Piece ABC, concrete piece classes, Board with __getitem__/__setitem__, Move dataclass, check detection, and algebraic notation.
Solve 11 Python __init__ and object construction — two-phase creation at engineering depth problems. Covers __init__ practice, object construction, __new__ v...
Solve 11 Python abstract base classes — enforcing interfaces at engineering depth problems. Covers abstract base, abc module, abstractmethod practice. Hints ...
Solve 11 Python classes and objects — python's object model at engineering depth problems. Covers classes and, class definition, object instantiation. Hints ...
Solve 11 Python composition vs inheritance — when to use each at engineering depth problems. Covers composition vs, composition over, delegation pattern. Hin...
Solve 11 Python dataclasses — code generation, immutability, and production patterns problems. Covers dataclasses practice, @dataclass exercises. Hints and s...
Solve 11 Python design patterns in python — idiomatic implementations for production code problems. Covers design patterns, singleton pattern, factory patter...
Solve 11 Python dunder methods — python's protocol system at engineering depth problems. Covers dunder methods, magic methods, operator overloading. Hints an...
Solve 11 Python encapsulation and data hiding — properties, name mangling, and descriptors problems. Covers encapsulation practice, properties exercises. Hin...
Solve 11 Python inheritance — single, multiple, and cooperative at engineering depth problems. Covers inheritance practice, single inheritance. Hints and sol...
Solve 11 Python mro — method resolution order and the c3 linearisation algorithm problems. Covers MRO practice, method resolution, C3 linearisation. Hints an...
Solve 11 Python representation and string methods — __repr__, __str__, __format__ at engineering depth problems. Covers __repr__ __str__, __format__ exercise...
Solve 11 Python solid principles in python — engineering patterns for maintainable code problems. Covers SOLID principles, single responsibility, open closed...
Master Python's string representation protocol - __repr__ vs __str__, the eval() contract, __format__ for custom f-string specs, __bytes__, the !r !s !a conversion flags, and how great repr() transforms production debugging.
Master all five SOLID principles with Python-specific implementations - SRP with module-level decomposition, OCP with typing.Protocol, LSP violations and their consequences, ISP with small focused ABCs, and DIP with constructor injection. Production code examples for each.
