While Python supports multiple inheritance, the course's focus on single inheritance reflects a sound design principle: single inheritance is easier to reason about, debug, and maintain. When inheritance is used appropriately, it models "is-a" relationships clearly and concisely.
class InitializerBase: def __init__(self): pass class LoggingMixin(InitializerBase): def __init__(self): print("Initialization started") super().__init__() class AuditingMixin(InitializerBase): def __init__(self): print("Audit record created") super().__init__() class SecureApplication(LoggingMixin, AuditingMixin): def __init__(self): super().__init__() Use code with caution. 6. Advanced Object Creational Lifecycle
Class attributes are shared across all instances, while instance attributes are unique to each object. Python's attribute resolution follows a clear lookup chain: it checks the instance's __dict__ first, then the class's __dict__ , and finally the base classes according to the Method Resolution Order (MRO). This mechanism, known as the "descriptor protocol," governs everything from method binding to property access. python 3 deep dive part 4 oop high quality
Descriptors power Python features like @property , @classmethod , and @staticmethod . A descriptor is an object that manages the access, modification, and deletion operations of an attribute on another class.
Descriptors are the secret behind methods, static methods, class methods, and properties. A descriptor is a class that defines __get__ , __set__ , or __delete__ . This mechanism, known as the "descriptor protocol," governs
Subtypes must be substitutable for their base types without altering program correctness. If a function expects a Rectangle , passing a Square (which inherits from Rectangle ) should work correctly. The classic "Square-Rectangle problem" illustrates how violating LSP—by overriding set_width and set_height inappropriately—leads to subtle bugs.
: Using super() is not just about calling the parent; it is about calling the next class in the MRO. This is essential for the "diamond problem" and ensuring all classes in a cooperative hierarchy are initialized exactly once. While Python doesn’t enforce strict privacy
class NonNegativeInteger: def __set_name__(self, owner, name): self.protected_name = f"_{name}" def __get__(self, instance, owner): if instance is None: return self return getattr(instance, self.protected_name, 0) def __set__(self, instance, value): if not isinstance(value, int) or value < 0: raise ValueError("Value must be a non-negative integer") setattr(instance, self.protected_name, value) class WarehouseInventory: stock_count = NonNegativeInteger() shelf_id = NonNegativeInteger() Use code with caution. Data vs. Non-Data Descriptors
class PositiveInteger: def __set_name__(self, owner, name): self.private_name = f"_{name}" def __get__(self, instance, objtype=None): if instance is None: return self return getattr(instance, self.private_name) def __set__(self, instance, value): if not isinstance(value, int) or value <= 0: raise ValueError(f"Value must be a positive integer.") setattr(instance, self.private_name, value) class InventoryItem: quantity = PositiveInteger() price = PositiveInteger() def __init__(self, name: str, quantity: int, price: int): self.name = name self.quantity = quantity self.price = price Use code with caution. 3. Deep Dive into Class Creation: __new__ vs __init__
Python relies on conventions to achieve these principles. For example, a _single_leading_underscore is a convention for "protected" attributes, while __double_leading_underscore triggers name mangling to avoid accidental overrides in subclasses. While Python doesn’t enforce strict privacy, the philosophy of "We are all consenting adults" empowers developers to respect these conventions without compromising flexibility.