Python Mastery Advanced Programming Course

Python uses a Method Resolution Order (MRO) to determine the sequence in which classes are searched when a method is called. This is accessible via the __mro__ attribute.

Single Inheritance

In a linear hierarchy, super() moves up the chain from child to parent.

Multiple Inheritance and Cooperative Inheritance

In multiple inheritance, super() does not necessarily delegate to the immediate parent of the current class. Instead, it moves to the next class in the MRO. The order of the MRO is determined by the order of classes provided in the subclass definition.

Key behaviors:

• The child class controls the order of the MRO.
• super() follows the MRO sequence, allowing different classes to be composed together.
• A common base class can serve as a terminator for a chain of super() calls if its methods do not call super().

>>> class Base:
        def spam(self):
            print('Base.spam')

>>> class X(Base):
        def spam(self):
            print('X.spam')
            super().spam()

>>> class Y(Base):
        def spam(self):
            print('Y.spam')
            super().spam()

>>> class Z(Base):
        def spam(self):
            print('Z.spam')
            super().spam()

>>> class M(X, Y, Z):
        pass

>>> M.__mro__
(<class '__main__.M'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class '__main__.Base'>, <class 'object'>)
>>> m = M()
>>> m.spam()
X.spam
Y.spam
Z.spam
Base.spam

You can implement attribute-level validation in Python classes by using the Descriptor protocol. By defining a class with a __set__ method, you can intercept attribute assignments and run validation logic via a check method.

Key components of this pattern:

• __set_name__(self, cls, name): Automatically captures the name of the attribute being assigned in the owner class.
• __set__(self, instance, value): Intercepts the assignment and applies validation logic before updating the instance's __dict__.
• check(cls, value): A class method used to perform the actual validation logic, which can be overridden by subclasses to implement specific constraints (like type checking or value ranges).

class Validator:
    def __init__(self, name=None):
        self.name = name

    def __set_name__(self, cls, name):
        self.name = name

    @classmethod
    def check(cls, value):
        return value

    def __set__(self, instance, value):
        instance.__dict__[self.name] = self.check(value)

You can use the @classmethod decorator to create alternate constructors for a class. This is useful for initializing an object from a different data format, such as a raw list or a CSV row. By using a class method like from_row(cls, row), you can encapsulate the logic for data conversion and type casting within the class itself, rather than performing it in the caller or the __init__ method.

A common pattern is to use a class variable (e.g., types) to define the expected types for each field, allowing the class method to iterate through the row and apply the corresponding conversion functions.

class Stock:
    types = (str, int, float)
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    @classmethod
    def from_row(cls, row):
        values = [func(val) for func, val in zip(cls.types, row)]
        return cls(*values)

Descriptors are objects that manage attribute access (getting, setting, and deleting) for other objects. They implement the descriptor protocol using specific magic methods. When you access an attribute on an instance, if that attribute is a descriptor defined in the class, Python automatically invokes the descriptor's methods instead of the default dictionary lookup.

Key methods in the protocol:

• __get__(self, instance, cls): Invoked when the attribute is accessed.
• __set__(self, instance, value): Invoked when the attribute is assigned a value.
• __delete__(self, instance): Invoked when the attribute is deleted.

class Descriptor:
    def __init__(self, name):
        self.name = name
    def __get__(self, instance, cls):
        print('%s:__get__' % self.name)
    def __set__(self, instance, value):
        print('%s:__set__ %s' % (self.name, value))
    def __delete__(self, instance):
        print('%s:__delete__' % self.name)

class Foo:
    a = Descriptor('a')

f = Foo()
f.a  # Triggers __get__
f.a = 23  # Triggers __set__
del f.a  # Triggers __delete__