1.2. Multiple Inheritance and Method Resolution Order (MRO)

Python allows a class to inherit from multiple parent classes, enabling more flexible designs.

class A:
    def greet(self):
        print("Hello from A")
class B:
    def greet(self):
        print("Hello from B")
class C(A, B):
    pass
obj = C()
obj.greet()  # Output: Hello from A

Multiple inheritance is a feature of Python that allows a class to inherit properties and methods from more than one parent class. In the code example, class A and class B both have a method named greet. When we create class C that inherits from both A and B, and then call obj.greet(), Python looks for the greet method starting from class C, then moves to A, and finally to B if it does not find it in C. Since A is listed first, the greet method from A is executed, resulting in 'Hello from A'.

Consider a person who inherits traits from both parents. If one parent has a talent for singing and the other for painting, a child might exhibit both talents. However, if the singing parent is the first to pass down the talent in our example, the child will be recognized for singing first.

MRO determines the order in which base classes are searched when executing a method. Python uses the C3 linearization algorithm to compute MRO, which ensures a consistent, predictable order.

You can inspect MRO using the __mro__ attribute or the mro() method:

print(C.__mro__)
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

The Method Resolution Order (MRO) is a way to define the sequence in which classes are looked up during method calls. Python follows the C3 linearization algorithm to maintain an order that reflects the hierarchy of classes. For our class C that inherits from A and B, the MRO shows that when a method is called, Python first checks class C, then class A, followed by class B, and finally goes up to the ultimate base class object. This systematic approach prevents ambiguity and ensures a clear path for method resolution.

Imagine a student looking for help with homework from various sources: first checking with their immediate teacher (class C), then with the teacher's assistant (class A), and finally with the school principal (class B). Each source provides information in a specific order, thus minimizing confusion.

Multiple inheritance can cause the 'diamond problem,' where a class inherits from two classes that both inherit from a common superclass.

class A:
    def greet(self):
        print("Hello from A")
class B(A):
    def greet(self):
        print("Hello from B")
class C(A):
    def greet(self):
        print("Hello from C")
class D(B, C):
    pass
obj = D()
obj.greet()  # Output: Hello from B
print(D.__mro__)
# MRO: <class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>

The diamond problem arises when a class inherits from two classes that both have the same parent class. In this example, D inherits from both B and C, which in turn inherit from A. Both B and C have their own greet() method, leading to ambiguity about which method D should use. MRO resolves this by determining the order of method lookups. When calling obj.greet(), MRO starts with D, then checks B (the first parent), which finds greet() and calls it, printing 'Hello from B'. The output reflects the method resolution defined by the MRO.

Think of a family reunion where two siblings (B and C) both have traits from the same parent (A). If a new family member (D) is asked to show a skill they learned, they might go to one sibling first for help. If the first sibling has already prepared instructions, the new member will follow their guidance instead of checking with the other sibling, resolving any potential confusion.

--