Method Resolution Order (MRO) in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Method Resolution Order (MRO) in Python?

MRO is the order in which Python looks for a method in a hierarchy of classes when you call it. It decides which method to run first when multiple classes have the same method name.

intermediate

How does Python determine the MRO for new-style classes?

Python uses the C3 linearization algorithm to create a consistent order of classes to search for methods, ensuring that subclasses come before their parents and preserving the order of base classes.

beginner

What does the __mro__ attribute show in a Python class?

The <code>__mro__</code> attribute is a tuple that shows the order in which Python will look for methods in the class hierarchy.

intermediate

What happens if there is a conflict in method names in multiple inheritance?

Python uses the MRO to decide which method to call. It picks the first method it finds following the MRO order, so the method in the class that appears earlier in the MRO is used.

beginner

How can you view the MRO of a class in Python?

You can view the MRO by using the ClassName.__mro__ attribute or the built-in function help(ClassName) which shows the method resolution order.

What does MRO stand for in Python?

A Method Return Output

B Method Resolution Order

C Module Runtime Operation

D Memory Reference Object

MRO stands for Method Resolution Order, which is the order Python follows to find methods in class inheritance.

Which algorithm does Python use to determine MRO for new-style classes?

A C3 linearization

B Depth-first search

C Breadth-first search

D Topological sort

Python uses the C3 linearization algorithm to create a consistent MRO.

What will ClassName.__mro__ return?

A A tuple of classes in the order Python searches for methods

B The list of all methods in the class

C The memory address of the class

D The source code of the class

__mro__ shows the order of classes Python checks for methods.

If two parent classes have the same method, which one is called?

A Both methods are called

B The method from the last parent class listed

C The method from the class that appears first in the MRO

D Python raises an error

Python calls the method from the class that comes first in the MRO.

How can you check the MRO of a class quickly?

A Use <code>print(ClassName)</code>

B Use <code>type(ClassName)</code>

C Use <code>dir(ClassName)</code>

D Use <code>ClassName.__mro__</code>

The __mro__ attribute shows the method resolution order.

Explain what Method Resolution Order (MRO) is and why it is important in Python.

Think about how Python decides which method to run when multiple classes have the same method.

Describe how Python determines the MRO for a class with multiple parents.

Consider the algorithm Python uses to keep the order consistent and predictable.

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