Interview Prepoop-design-patternsmediumAmazonGoogleMicrosoftFlipkartTCSInfosys

Inheritance - Types, Method Resolution Order & Diamond Problem

Choose your preparation mode3 modes available

Solution Trace

Start learning this pattern below

Jump into concepts and practice - no test required

Recommended

Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong

▶

Steps

setup

Define Base Class A

We define the base class A with a method 'method' that prints 'A'. This is the root of the diamond.

💡 Starting with the base class is essential to understand how derived classes inherit and override methods.

Line:

class A:
    def method(self):
        print('A')

💡 Base class methods form the foundation for inheritance and method resolution.

setup

Define Class B inheriting from A

Class B is defined as a subclass of A and overrides the 'method' to print 'B'.

💡 This shows simple single inheritance and method overriding.

Line:

class B(A):
    def method(self):
        print('B')

💡 Subclass B overrides the base method, demonstrating polymorphism.

setup

Define Class C inheriting from A

Class C is defined as another subclass of A and overrides 'method' to print 'C'.

💡 This creates the second branch of the diamond, showing multiple inheritance paths.

Line:

class C(A):
    def method(self):
        print('C')

💡 Multiple subclasses can override the same base method independently.

setup

Define Class D inheriting from B and C

Class D is defined inheriting from both B and C, creating the diamond inheritance structure.

💡 Multiple inheritance introduces complexity in method resolution order.

Line:

class D(B, C):
    pass

💡 D inherits from two classes that both override the same method, setting up the diamond problem.

expand

Compute Method Resolution Order (MRO) for D

Python computes the MRO for class D to determine the order in which methods are resolved.

💡 MRO is critical to avoid ambiguity in multiple inheritance by defining a linear order.

Line:print(D.__mro__)

💡 MRO ensures a consistent and unambiguous method lookup path.

traverse

Invoke method() on instance of D

Create an instance of D and call its 'method'. The interpreter will use the MRO to resolve which method to execute.

💡 This step shows how the MRO affects actual method calls in multiple inheritance.

Line:

d = D()
d.method()

💡 Method calls on D follow the MRO order to find the first matching method.

compare

Method lookup: Check D for method

The interpreter checks if class D defines 'method'. It does not, so it proceeds to the next class in MRO.

💡 Understanding that the search starts at the instance's class is key to method resolution.

Line:d.method() # lookup starts at D

💡 Method resolution follows the MRO sequence strictly.

compare

Method lookup: Found method in B

Class B defines 'method', so this implementation is selected and will be executed.

💡 The first class in MRO with the method is used, preventing ambiguity.

Line:d.method() # method found in B

💡 MRO ensures a unique method is chosen even with multiple inheritance.

traverse

Execute B.method()

The method implementation in B is executed, printing 'B'.

💡 This confirms the method resolution order works as expected in practice.

Line:d.method() # executes B.method()

💡 The method output matches the MRO resolution, demonstrating correctness.

reconstruct

Summary: Diamond Problem Resolved by MRO

The diamond inheritance problem is resolved by Python's MRO, which linearizes the inheritance graph and ensures a unique method resolution path.

💡 This final step consolidates understanding of how multiple inheritance ambiguity is avoided.

Line:# Summary step, no code executed

💡 MRO is a powerful mechanism that prevents ambiguity and ensures predictable method calls in complex inheritance.

class A:  # STEP 1
    def method(self):  # STEP 1
        print('A')  # STEP 1

class B(A):  # STEP 2
    def method(self):  # STEP 2
        print('B')  # STEP 2

class C(A):  # STEP 3
    def method(self):  # STEP 3
        print('C')  # STEP 3

class D(B, C):  # STEP 4
    pass  # STEP 4

print(D.__mro__)  # STEP 5

d = D()  # STEP 6
 d.method()  # STEP 6-9

📊

Inheritance - Types, Method Resolution Order & Diamond Problem - Watch the Algorithm Execute, Step by Step

Watching the step-by-step construction and method lookup in the diamond inheritance pattern reveals the subtlety of MRO and why it matters to avoid ambiguity.

Step 1/10

·Active fill★Answer cell

Defines base class with a concrete method.

+method()

Subclass B overrides method from A.

+method()

B ▷ A (1:1)

Subclass C overrides method from A.

+method()

B ▷ A (1:1)C ▷ A (1:1)

Multiple inheritance creates diamond shape.

+method()