Method Resolution Order (MRO) in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of MRO with multiple inheritance

What is the output of this Python code when calling obj.method()?

Python

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

obj = D()
print(obj.method())

A D

B C

C B

D A

💡 Hint

Remember Python uses C3 linearization for MRO and checks parents left to right.

Class D inherits from B and C. B overrides method() to return 'B', C returns 'C'. Python looks for method in D, then B, then C, then A. So it finds B's method first.

❓ Predict Output

intermediate

MRO list of a complex class

What is the output of print(E.__mro__) for the following code?

Python

class X:
    pass

class Y(X):
    pass

class Z(X):
    pass

class W(Y, Z):
    pass

class E(W, Z):
    pass

print(E.__mro__)

A (E, W, Z, Y, X, object)

B (E, W, Y, Z, X, object)

C (E, W, Y, Z, object, X)

D (E, W, Y, X, Z, object)

💡 Hint

Check the order of base classes and how Python merges MROs.

Python merges MROs of parents using C3 linearization. E inherits from W and Z. W inherits from Y and Z. The final MRO is (E, W, Y, Z, X, object).

🔧 Debug

advanced

Identify the cause of MRO conflict error

Why does this code raise a TypeError: Cannot create a consistent method resolution order (MRO)?

Python

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

class E(C, B):
    pass

class F(D, E):
    pass

A Because classes D and E inherit from B and C in different orders causing MRO conflict in F

B Because class A is missing a method required by F

C Because class F does not define its own __init__ method

D Because classes B and C have no common base class

💡 Hint

Look at the order of base classes in D and E and how F inherits from both.

D inherits from B then C, E inherits from C then B. When F inherits from D and E, Python cannot find a consistent order that respects both, causing the MRO conflict error.

❓ Predict Output

advanced

Output of super() in diamond inheritance

What is the output of this code?

Python

class Root:
    def greet(self):
        return "Hello from Root"

class Left(Root):
    def greet(self):
        return "Left says " + super().greet()

class Right(Root):
    def greet(self):
        return "Right says " + super().greet()

class Child(Left, Right):
    def greet(self):
        return "Child says " + super().greet()

obj = Child()
print(obj.greet())

A Child says Left says Right says Hello from Root

B Child says Right says Left says Hello from Root

C Child says Left says Hello from Root

D Child says Hello from Root

💡 Hint

super() follows the MRO chain, calling next method in order.

Child's MRO is [Child, Left, Right, Root, object]. Each greet calls super().greet(), so calls chain Left -> Right -> Root.

🧠 Conceptual

expert

Understanding MRO with metaclasses

Given the following code, what is the output of print(type(C).__mro__)?

Python

class Meta(type):
    pass

class A(metaclass=Meta):
    pass

class B(A):
    pass

class C(B):
    pass

print(type(C).__mro__)

A (<class '__main__.Meta'>, <class 'object'>, <class 'type'>)

B (<class 'type'>, <class 'object'>)

C (<class 'type'>, <class '__main__.Meta'>, <class 'object'>)

D (<class '__main__.Meta'>, <class 'type'>, <class 'object'>)

💡 Hint

Remember that the type of a class is its metaclass, and metaclasses inherit from type.

C is a class whose metaclass is Meta (inherited from A). The type of C is Meta. Meta inherits from type, so MRO is (Meta, type, object).

Practice

1. What does Method Resolution Order (MRO) in Python determine?

easy

A. The order Python compiles code

B. The order Python executes loops

C. The order Python looks for methods in inheritance

D. The order Python imports modules

Solution

1. Step 1: Understand MRO purpose

   MRO defines the sequence Python follows to find methods in classes with inheritance.

2. Step 2: Compare options

   Only The order Python looks for methods in inheritance correctly describes MRO's role in method lookup order.

3. Final Answer:

   The order Python looks for methods in inheritance -> Option C

4. Quick Check:

   MRO = method lookup order [OK]

Hint: MRO is about method search order in inheritance [OK]

Common Mistakes:

• Confusing MRO with loop or import order
• Thinking MRO controls code compilation
• Mixing MRO with unrelated Python features

2. Which of the following is the correct way to check the MRO of a class MyClass in Python?

easy

A. print(MyClass.__mro__)

B. print(MyClass.get_mro())

C. print(MyClass.MRO())

D. print(MyClass.mro)

Solution

1. Step 1: Recall MRO access methods

   Python provides __mro__ attribute and mro() method to check MRO.

2. Step 2: Identify correct syntax

   MyClass.__mro__ is a tuple showing MRO; MyClass.mro() is a method returning a list. print(MyClass.__mro__) uses __mro__ correctly with print.

3. Final Answer:

   print(MyClass.__mro__) -> Option A

4. Quick Check:

   Use __mro__ attribute to check MRO [OK]

Hint: Use ClassName.__mro__ to see MRO tuple [OK]

Common Mistakes:

• Using non-existent get_mro() method
• Forgetting parentheses for mro() method
• Trying to print mro without calling it

3. What will be the output of the following code?

class A:
    def greet(self):
        return 'Hello from A'

class B(A):
    def greet(self):
        return 'Hello from B'

class C(A):
    def greet(self):
        return 'Hello from C'

class D(B, C):
    pass

print(D().greet())

medium

A. 'Hello from B'

B. 'Hello from A'

C. 'Hello from C'

D. Error: Ambiguous method

Solution

1. Step 1: Determine MRO of class D

   Class D inherits from B and C. Python uses C3 linearization: D > B > C > A.

2. Step 2: Find first greet method in MRO

   Method greet is found first in B, so D().greet() calls B's greet method.

3. Final Answer:

   'Hello from B' -> Option A

4. Quick Check:

   MRO order picks B's greet first [OK]

Hint: MRO checks parents left to right, first method wins [OK]

Common Mistakes:

• Assuming C's greet is called instead of B's
• Thinking A's greet is called directly
• Expecting an error due to multiple inheritance

4. Consider the following code snippet. What is the error and how to fix it?

class X:
    def method(self):
        return 'X'

class Y:
    def method(self):
        return 'Y'

class Z(X, Y):
    def method(self):
        return super().method()

print(Z().method())

medium

A. Error: super() call is ambiguous; fix by specifying class and self

B. Output: 'X' (no error)

C. Output: 'Y' (no error)

D. Error: Missing parentheses in print statement

Solution

1. Step 1: Analyze super() in Z.method()

   super() calls next method in MRO after Z, which is X.method().

2. Step 2: Check output of X.method()

   X.method() returns 'X', so print outputs 'X' with no error.

3. Final Answer:

   Output: 'X' (no error) -> Option B

4. Quick Check:

   super() calls next in MRO, here X.method() [OK]

Hint: super() calls next method in MRO automatically [OK]

Common Mistakes:

• Thinking super() needs explicit class and self
• Expecting output 'Y' instead of 'X'
• Assuming syntax error in print statement

5. Given the classes below, what is the MRO of class F?

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
class E(C, B): pass
class F(D, E): pass

hard

A. (F, E, D, B, C, A, object)

B. (F, D, E, B, C, A, object)

C. (F, D, B, C, E, C, B, A, object)

D. TypeError due to inconsistent MRO

Solution

1. Step 1: Understand MRO consistency rules

   Python requires MRO to be consistent and follow C3 linearization rules.

2. Step 2: Check classes D and E inheritance

   D inherits B then C; E inherits C then B. This creates conflicting order for F inheriting D and E.

3. Step 3: Result of conflict

   Python raises TypeError for class F due to inconsistent MRO from conflicting parent orders.

4. Final Answer:

   TypeError due to inconsistent MRO -> Option D

5. Quick Check:

   Conflicting parent order causes TypeError [OK]

Hint: Conflicting parent order causes MRO TypeError [OK]

Common Mistakes:

• Assuming Python picks one MRO silently
• Ignoring C3 linearization rules
• Trying to list MRO despite conflict