Method Resolution Order (MRO) in Python0%

Method Resolution Order (MRO) in Python

Advanced8 min read•Updated: 2026-10-01

Method Resolution Order (MRO) and C3 Linearization in Python

In complex object-oriented systems with multiple inheritance, determining which parent version of a method executes is not always trivial. Python resolves method lookups deterministically using the Method Resolution Order (MRO), calculated via the sophisticated C3 Linearization Algorithm. Understanding MRO is essential for mastering cooperative multiple inheritance, mixins, and large Python frameworks.

1. The Diamond Problem

The classic dilemma in multiple inheritance is the Diamond Problem:

Visual Architecture Blueprint

+------------------+
               |     Class A      |
               |  def action()    |
               +------------------+
                    /        \
                   /          \
      +------------------+  +------------------+
      |     Class B      |  |     Class C      |
      |  def action()    |  |  def action()    |
      +------------------+  +------------------+
                   \          /
                    \        /
               +------------------+
               |     Class D      |
               |    (B, C)        |
               +------------------+

If Class D inherits from both B and C, and all three define action(), which method should execute when calling D().action()?

In naive Depth-First Search (used in Python 2.1), A would be visited before C, meaning A's outdated base method could override C's specialized method!
Python solves this with C3 Linearization, ensuring that derived classes always precede their ancestors.

2. Inspecting the MRO

You can inspect the linear resolution order of any class using two attributes:

ClassName.__mro__: Returns a tuple of classes in resolution order.
ClassName.mro(): Returns the same order as a list.

1class A:
2    def action(self):
3        print("A's action")
4 
5class B(A):
6    def action(self):
7        print("B's action")
8 
9class C(A):
10    def action(self):
11        print("C's action")
12 
13class D(B, C):
14    pass
15 
16d = D()
17d.action()  # Output: B's action
18 
19# Inspecting the exact linear search sequence:
20print([cls.__name__ for cls in D.__mro__])
21# Output: ['D', 'B', 'C', 'A', 'object']

Python searches classes strictly from left to right along this sequence: D $\rightarrow$ B $\rightarrow$ C $\rightarrow$ A $\rightarrow$ object.

3. The Mathematics of C3 Linearization

The C3 algorithm guarantees three fundamental properties:

1
Local Precedence Order: In class D(B, C), class B is always evaluated before class C.
2
Monotonicity: If class X precedes class Y in the MRO of any parent class, X will precede Y in the MRO of any derived class.
3
Single Appearance: Each ancestor class appears exactly once in the MRO list.

The Linearization Formula:

$$L[C(B_1, B_2, \dots, B_N)] = C + \text{merge}(L[B_1], L[B_2], \dots, L[B_N], (B_1, B_2, \dots, B_N))$$

The merge operation inspects the head of each candidate list. If a head class is not present in the tail (any position other than the first) of any other list, it is extracted and appended to the MRO output.

4. `super()` is NOT "Call Parent"—It is "Call Next in MRO"!

One of the most widespread misconceptions in Python is that super() simply calls the direct parent class.

super() actually calls the NEXT class in the active MRO sequence of the originating instance!

Notice how super() in class B actually calls class C (its sibling!), not its parent A:

1class Root:
2    def ping(self):
3        print("Root.ping()")
4 
5class A(Root):
6    def ping(self):
7        print("A.ping() start")
8        super().ping()
9        print("A.ping() end")
10 
11class B(Root):
12    def ping(self):
13        print("B.ping() start")
14        super().ping()  # In class C(A, B), this calls Root, but in C(B, A), super() calls A!
15        print("B.ping() end")
16 
17class Composite(A, B):
18    def ping(self):
19        print("Composite.ping() start")
20        super().ping()
21        print("Composite.ping() end")
22 
23print("MRO:", [cls.__name__ for cls in Composite.__mro__])
24# ['Composite', 'A', 'B', 'Root', 'object']
25 
26c = Composite()
27c.ping()

Output:

1Composite.ping() start
2A.ping() start
3B.ping() start
4Root.ping()
5B.ping() end
6A.ping() end
7Composite.ping() end

A's call to super().ping() invoked B.ping()! This cooperative dispatch pattern enables multi-tiered mixin architectures without hardcoded dependencies.

5. Inconsistent MRO: When Python Refuses to Compile

If an inheritance hierarchy violates the local precedence rules, the C3 merge algorithm fails, and Python refuses to create the class with a TypeError:

1class X: pass
2class Y(X): pass
3 
4# Fails! X cannot precede Y because Y inherits from X!
5try:
6    class Invalid(X, Y):
7        pass
8except TypeError as err:
9    print(f"Compilation Blocked: {err}")
10    # TypeError: Cannot create a consistent method resolution order (MRO) for bases X, Y

⚠️ Common Advanced Mistakes & Gotchas

1. Bypassing `super()` with Direct Base Class Calls

Calling Parent.__init__(self) directly in multiple inheritance violates C3 Linearization and causes common ancestor constructors to be invoked multiple times in diamond hierarchies. Always use cooperative super().__init__().

2. Inconsistent Hierarchy Signatures

Cooperative multiple inheritance requires that all participating classes accept consistent arguments or forward extra arguments with *args, **kwargs.

💻 Try It Yourself: Inspecting C3 Linearization in Diamonds

Scenario

Construct a classic diamond inheritance hierarchy with classes A, B(A), C(A), and D(B, C). Use cooperative super() calls and inspect D.__mro__.

Complete Solution

1class A:
2    def ping(self):
3        print("A.ping()")
4 
5class B(A):
6    def ping(self):
7        print("B.ping() -> calling super")
8        super().ping()
9 
10class C(A):
11    def ping(self):
12        print("C.ping() -> calling super")
13        super().ping()
14 
15class D(B, C):
16    def ping(self):
17        print("D.ping() -> calling super")
18        super().ping()
19 
20d = D()
21d.ping()
22print("
23Method Resolution Order (MRO):")
24for idx, cls in enumerate(D.__mro__, 1):
25    print(f"{idx}. {cls.__name__}")

Expected Output

1D.ping() -> calling super
2B.ping() -> calling super
3C.ping() -> calling super
4A.ping()
5 
6Method Resolution Order (MRO):
71. D
82. B
93. C
104. A
115. object

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

Which algorithm does Python use to compute the Method Resolution Order (MRO)?

Question 2

In class D(B, C): pass, what does D.__mro__ return?

Question 3

What does super() actually invoke in Python?

Question 4

What happens if a class definition creates an inheritance conflict that violates C3 linearity?

Question 5

In the diamond inheritance class D(B, C) where both B and C inherit from A, why does C execute before A in the MRO?

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Multiple Inheritance (1: Advanced OOP Concepts).

👉 Continue to Next Lesson: Multiple Inheritance →

Next Lesson

Multiple Inheritance

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Property Decorator	Multiple Inheritance

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Multiple Inheritance

Method Resolution Order (MRO) in Python

Advanced8 min read•Updated: 2026-10-01

Study Materials Cheatsheet

Method Resolution Order (MRO) and C3 Linearization in Python

1. The Diamond Problem

The classic dilemma in multiple inheritance is the Diamond Problem:

Visual Architecture Blueprint

+------------------+
               |     Class A      |
               |  def action()    |
               +------------------+
                    /        \
                   /          \
      +------------------+  +------------------+
      |     Class B      |  |     Class C      |
      |  def action()    |  |  def action()    |
      +------------------+  +------------------+
                   \          /
                    \        /
               +------------------+
               |     Class D      |
               |    (B, C)        |
               +------------------+

If Class D inherits from both B and C, and all three define action(), which method should execute when calling D().action()?

In naive Depth-First Search (used in Python 2.1), A would be visited before C, meaning A's outdated base method could override C's specialized method!
Python solves this with C3 Linearization, ensuring that derived classes always precede their ancestors.

2. Inspecting the MRO

You can inspect the linear resolution order of any class using two attributes:

ClassName.__mro__: Returns a tuple of classes in resolution order.
ClassName.mro(): Returns the same order as a list.

1class A:
2    def action(self):
3        print("A's action")
4 
5class B(A):
6    def action(self):
7        print("B's action")
8 
9class C(A):
10    def action(self):
11        print("C's action")
12 
13class D(B, C):
14    pass
15 
16d = D()
17d.action()  # Output: B's action
18 
19# Inspecting the exact linear search sequence:
20print([cls.__name__ for cls in D.__mro__])
21# Output: ['D', 'B', 'C', 'A', 'object']

Python searches classes strictly from left to right along this sequence: D $\rightarrow$ B $\rightarrow$ C $\rightarrow$ A $\rightarrow$ object.

3. The Mathematics of C3 Linearization

The C3 algorithm guarantees three fundamental properties:

1
Local Precedence Order: In class D(B, C), class B is always evaluated before class C.
2
Monotonicity: If class X precedes class Y in the MRO of any parent class, X will precede Y in the MRO of any derived class.
3
Single Appearance: Each ancestor class appears exactly once in the MRO list.

The Linearization Formula:

$$L[C(B_1, B_2, \dots, B_N)] = C + \text{merge}(L[B_1], L[B_2], \dots, L[B_N], (B_1, B_2, \dots, B_N))$$

4. `super()` is NOT "Call Parent"—It is "Call Next in MRO"!

One of the most widespread misconceptions in Python is that super() simply calls the direct parent class.

super() actually calls the NEXT class in the active MRO sequence of the originating instance!

Notice how super() in class B actually calls class C (its sibling!), not its parent A:

1class Root:
2    def ping(self):
3        print("Root.ping()")
4 
5class A(Root):
6    def ping(self):
7        print("A.ping() start")
8        super().ping()
9        print("A.ping() end")
10 
11class B(Root):
12    def ping(self):
13        print("B.ping() start")
14        super().ping()  # In class C(A, B), this calls Root, but in C(B, A), super() calls A!
15        print("B.ping() end")
16 
17class Composite(A, B):
18    def ping(self):
19        print("Composite.ping() start")
20        super().ping()
21        print("Composite.ping() end")
22 
23print("MRO:", [cls.__name__ for cls in Composite.__mro__])
24# ['Composite', 'A', 'B', 'Root', 'object']
25 
26c = Composite()
27c.ping()

Output:

1Composite.ping() start
2A.ping() start
3B.ping() start
4Root.ping()
5B.ping() end
6A.ping() end
7Composite.ping() end

A's call to super().ping() invoked B.ping()! This cooperative dispatch pattern enables multi-tiered mixin architectures without hardcoded dependencies.

5. Inconsistent MRO: When Python Refuses to Compile

If an inheritance hierarchy violates the local precedence rules, the C3 merge algorithm fails, and Python refuses to create the class with a TypeError:

1class X: pass
2class Y(X): pass
3 
4# Fails! X cannot precede Y because Y inherits from X!
5try:
6    class Invalid(X, Y):
7        pass
8except TypeError as err:
9    print(f"Compilation Blocked: {err}")
10    # TypeError: Cannot create a consistent method resolution order (MRO) for bases X, Y

⚠️ Common Advanced Mistakes & Gotchas

1. Bypassing `super()` with Direct Base Class Calls

2. Inconsistent Hierarchy Signatures

Cooperative multiple inheritance requires that all participating classes accept consistent arguments or forward extra arguments with *args, **kwargs.

💻 Try It Yourself: Inspecting C3 Linearization in Diamonds

Scenario

Construct a classic diamond inheritance hierarchy with classes A, B(A), C(A), and D(B, C). Use cooperative super() calls and inspect D.__mro__.

Complete Solution

1class A:
2    def ping(self):
3        print("A.ping()")
4 
5class B(A):
6    def ping(self):
7        print("B.ping() -> calling super")
8        super().ping()
9 
10class C(A):
11    def ping(self):
12        print("C.ping() -> calling super")
13        super().ping()
14 
15class D(B, C):
16    def ping(self):
17        print("D.ping() -> calling super")
18        super().ping()
19 
20d = D()
21d.ping()
22print("
23Method Resolution Order (MRO):")
24for idx, cls in enumerate(D.__mro__, 1):
25    print(f"{idx}. {cls.__name__}")

Expected Output

1D.ping() -> calling super
2B.ping() -> calling super
3C.ping() -> calling super
4A.ping()
5 
6Method Resolution Order (MRO):
71. D
82. B
93. C
104. A
115. object

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

Which algorithm does Python use to compute the Method Resolution Order (MRO)?

Question 2

In class D(B, C): pass, what does D.__mro__ return?

Question 3

What does super() actually invoke in Python?

Question 4

What happens if a class definition creates an inheritance conflict that violates C3 linearity?

Question 5

In the diamond inheritance class D(B, C) where both B and C inherit from A, why does C execute before A in the MRO?

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Multiple Inheritance (1: Advanced OOP Concepts).

👉 Continue to Next Lesson: Multiple Inheritance →

Next Lesson

Multiple Inheritance

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Property Decorator	Multiple Inheritance

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

Method Resolution Order (MRO) and C3 Linearization in Python

1. The Diamond Problem

2. Inspecting the MRO

3. The Mathematics of C3 Linearization

The Linearization Formula:

4. super() is NOT "Call Parent"—It is "Call Next in MRO"!

Output:

5. Inconsistent MRO: When Python Refuses to Compile

⚠️ Common Advanced Mistakes & Gotchas

1. Bypassing super() with Direct Base Class Calls

2. Inconsistent Hierarchy Signatures

💻 Try It Yourself: Inspecting C3 Linearization in Diamonds

Scenario

Complete Solution

Expected Output

Practice Quiz

🚀 What's Next?

Multiple Inheritance

Related Lessons

Practice Quiz

Loading Page Content...

Method Resolution Order (MRO) and C3 Linearization in Python

1. The Diamond Problem

2. Inspecting the MRO

3. The Mathematics of C3 Linearization

The Linearization Formula:

4. super() is NOT "Call Parent"—It is "Call Next in MRO"!

Output:

5. Inconsistent MRO: When Python Refuses to Compile

⚠️ Common Advanced Mistakes & Gotchas

1. Bypassing super() with Direct Base Class Calls

2. Inconsistent Hierarchy Signatures

💻 Try It Yourself: Inspecting C3 Linearization in Diamonds

Scenario

Complete Solution

Expected Output

Practice Quiz

🚀 What's Next?

Multiple Inheritance

Related Lessons

Practice Quiz

4. `super()` is NOT "Call Parent"—It is "Call Next in MRO"!

1. Bypassing `super()` with Direct Base Class Calls

4. `super()` is NOT "Call Parent"—It is "Call Next in MRO"!

1. Bypassing `super()` with Direct Base Class Calls