Python - Method Resolution Order (MRO)

Method Resolution Order (MRO) in Python

Introduction

Python is an object-oriented programming language that supports multiple inheritance. One of the key challenges with multiple inheritance is determining the order in which base classes are searched when a method or attribute is referenced. This order is defined by the Method Resolution Order (MRO). Understanding MRO is crucial when working with class hierarchies in Python to predict and control method lookups.

This document explores how Python resolves methods and attributes in single and multiple inheritance hierarchies using the C3 Linearization algorithm. We will cover the basics of inheritance, dive deep into how MRO works, explore complex inheritance trees, and discuss best practices.

Basics of Inheritance

Single Inheritance

In single inheritance, a subclass inherits from one superclass.

class A:
    def greet(self):
        print("Hello from A")

class B(A):
    pass

obj = B()
obj.greet()  # Output: Hello from A

Multiple Inheritance

In multiple inheritance, a subclass inherits from more than one superclass.

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

In this example, Python searches for greet in C, then A, and then B. This is determined by MRO.

What is MRO?

Definition

Method Resolution Order (MRO) is the sequence in which base classes are searched when executing a method or looking up an attribute. Python uses the C3 linearization algorithm to compute the MRO in new-style classes (all classes in Python 3 are new-style).

View MRO with __mro__

class A: pass
class B(A): pass

print(B.__mro__)

Using mro() Method

print(B.mro())

Understanding the C3 Linearization Algorithm

What is C3 Linearization?

The C3 linearization algorithm ensures a consistent and predictable order of method resolution by following three rules:

1. A class always appears before its parents.
2. The order of parents is preserved.
3. No class appears more than once in the hierarchy.

How C3 Works

It merges the MROs of parent classes and the list of parents in the order they are defined, ensuring all rules are satisfied.

Single Inheritance MRO

Example

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

b = B()
b.show()  # Output: B
print(B.__mro__)

Output

(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Multiple Inheritance MRO

Example

class A:
    def show(self):
        print("A")

class B:
    def show(self):
        print("B")

class C(A, B):
    pass

c = C()
c.show()  # Output: A
print(C.mro())

Explanation

The method is found in A before B because A is listed first in the inheritance list.

Complex Inheritance with MRO

Diamond Problem

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

d = D()
d.show()  # Output: B
print(D.mro())

Output

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

Explanation

The MRO of D is [D, B, C, A, object]. Python uses the C3 algorithm to resolve this order and avoids ambiguity.

Conflicting Inheritance Orders

Invalid MRO

class X: pass
class Y: pass
class A(X, Y): pass
class B(Y, X): pass
# class C(A, B): pass  # Will raise TypeError

Explanation

This raises a TypeError because there’s no consistent MRO due to conflicting base class orders.

Using super() and MRO

super() and Method Chaining

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")
        super().show()

class C(B):
    def show(self):
        print("C")
        super().show()

c = C()
c.show()

Output

C
B
A

Explanation

Each class uses super() to call the next method in the MRO chain.

Benefits of MRO

Determinism

The C3 algorithm ensures that method resolution is deterministic and predictable.

Consistent super()

All calls to super() resolve to the next class in the MRO, ensuring consistent behavior in cooperative multiple inheritance.

Best Practices

Always Use super()

Using super() ensures that all base classes in the MRO get a chance to contribute.

Avoid Deep Multiple Inheritance

Prefer composition over deep inheritance hierarchies to avoid complexity and potential MRO conflicts.

Check MRO with mro()

Use ClassName.mro() to debug and verify the method resolution order.

Real-World Application

Example: Logging and Validation

class Base:
    def process(self):
        print("Base process")

class Logger(Base):
    def process(self):
        print("Logging")
        super().process()

class Validator(Base):
    def process(self):
        print("Validating")
        super().process()

class App(Logger, Validator):
    def process(self):
        print("App logic")
        super().process()

a = App()
a.process()

Output

App logic
Logging
Validating
Base process

MRO with Built-in Types

Example with list

class MyList(list):
    pass

print(MyList.__mro__)

Output

(<class '__main__.MyList'>, <class 'list'>, <class 'object'>)

MRO in Abstract Base Classes

Using ABC Module

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        print("Bark")

d = Dog()
d.sound()
print(Dog.__mro__)

Visualizing MRO

Use print(class.__mro__)

Always print the MRO to debug inheritance chains and ensure super() behaves as expected.

Use Tools

Third-party tools and IDEs like PyCharm or VS Code can visualize class hierarchies and MRO.

The Method Resolution Order (MRO) in Python is essential for understanding how Python looks up methods and attributes in class hierarchies. The C3 linearization algorithm provides a deterministic and conflict-free resolution order, particularly important when dealing with multiple inheritance.

By mastering MRO, developers can:

• Write maintainable and predictable code
• Build complex hierarchies safely
• Utilize cooperative multiple inheritance effectively with super()

Always inspect and understand the MRO when designing class hierarchies, especially with multiple inheritance. The clarity and power it brings to Python object-oriented design is invaluable for building robust systems.