Diamond problem in Python - Step-by-Step Execution

Concept Flow - Diamond problem

Class A

↓

Class B

↓

Class D

↓

Create instance of D

↓

Method call

↓

Resolve method via MRO

↓

Execute method

Shows how Python resolves method calls in a diamond inheritance pattern using Method Resolution Order (MRO).

Execution Sample

Python

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

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

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

class D(B, C):
    pass

obj = D()
obj.greet()

Defines classes in a diamond shape and calls greet() on D instance to show MRO in action.

Execution Table

Step	Action	Evaluation	Result
1	Create class A with greet()	Method greet defined in A	A.greet() available
2	Create class B inheriting A with greet()	Overrides greet()	B.greet() available
3	Create class C inheriting A with greet()	Overrides greet()	C.greet() available
4	Create class D inheriting B and C	No greet() defined	D inherits from B and C
5	Create instance obj of D	obj is instance of D	obj ready
6	Call obj.greet()	Look for greet in D	Not found in D
7	Check B for greet()	Found greet() in B	Use B.greet()
8	Execute B.greet()	Prints 'Hello from B'	Output: Hello from B
9	End	Method call complete	Execution stops

💡 Method greet found in B during MRO, so execution stops after printing.

Variable Tracker

Variable	Start	After Step 5	After Step 6	After Step 7	Final
obj	undefined	instance of D	instance of D	instance of D	instance of D

Key Moments - 3 Insights

Why does obj.greet() call B's greet() and not C's or A's?

Because Python uses Method Resolution Order (MRO) which checks classes in the order D -> B -> C -> A. The execution_table row 7 shows greet() found first in B.

What happens if class D defines its own greet() method?

Then obj.greet() would call D's greet() directly, skipping B and C. This is because the method is found immediately in D (see execution_table row 6).

Why is the diamond problem not causing ambiguity here?

Python's MRO linearizes the inheritance so only one path is chosen. The execution_table shows the order checked, preventing ambiguity.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the greet() method found for obj.greet()?

A Step 7

B Step 6

C Step 8

D Step 4

💡 Hint

Check the 'Evaluation' column in execution_table rows 6 and 7 to see where greet() is found.

According to variable_tracker, what is the value of obj after step 5?

A undefined

B instance of A

C instance of D

D instance of B

💡 Hint

Look at variable_tracker row for obj under 'After Step 5'.

If class D had its own greet() method, how would the execution_table change at step 6?

A greet() found in C at step 7

B greet() found in D at step 6

C greet() found in B at step 7

D No greet() found, error

💡 Hint

Refer to key_moments explanation about method overriding and execution_table step 6.

Concept Snapshot

Diamond problem occurs when a class inherits from two classes that share a common ancestor.
Python solves this using Method Resolution Order (MRO).
MRO defines a linear order to search methods.
In diamond shape, MRO prevents ambiguity by choosing one path.
Use class.__mro__ to see the order.
Method calls follow this order to find the right method.

Full Transcript

This visual trace shows how Python handles the diamond problem in multiple inheritance. We define classes A, B, C, and D where B and C inherit from A, and D inherits from B and C. When we create an instance of D and call greet(), Python looks for the method in D first, then B, then C, then A. It finds greet() in B and executes it, printing 'Hello from B'. This is because Python uses Method Resolution Order (MRO) to avoid ambiguity in diamond inheritance. The variable tracker shows obj is an instance of D throughout. Key moments clarify why B's greet() is chosen and how defining greet() in D would change the behavior. The quizzes test understanding of method lookup steps and variable states. This helps beginners see step-by-step how Python resolves methods in diamond inheritance.

Practice

1.

What is the diamond problem in Python's multiple inheritance?

easy

A. A problem where Python cannot find any method in the class hierarchy.

B. A syntax error caused by using multiple inheritance.

C. A situation where a class inherits from two classes that both inherit from the same base class.

D. A situation where a class inherits from only one base class.

Solution

1. Step 1: Understand multiple inheritance structure

   The diamond problem occurs when a class inherits from two classes that share a common ancestor, forming a diamond shape in the inheritance graph.

2. Step 2: Recognize the diamond shape

   This shape causes ambiguity in method resolution because the common base class appears twice in the inheritance path.

3. Final Answer:

   A situation where a class inherits from two classes that both inherit from the same base class. -> Option C

4. Quick Check:

   Diamond problem = multiple inheritance with shared base [OK]

Hint: Diamond problem = shared base class inherited twice [OK]

Common Mistakes:

• Thinking diamond problem is a syntax error
• Confusing single inheritance with diamond problem
• Believing diamond problem means no methods found

2.

Which of the following class definitions correctly shows multiple inheritance that can cause the diamond problem?

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(??):
    pass

What should replace ???

easy

A. A, B

B. B, C

C. C, B

D. A, C

Solution

1. Step 1: Identify classes inheriting from A

   Classes B and C both inherit from A, so they form the upper branches of the diamond.

2. Step 2: Define class D inheriting from B and C

   To create the diamond shape, D must inherit from both B and C.

3. Final Answer:

   B, C -> Option B

4. Quick Check:

   Diamond bottom inherits from both branches [OK]

Hint: Diamond bottom class inherits from both intermediate classes [OK]

Common Mistakes:

• Using A directly in D's inheritance
• Swapping order without reason
• Using only one parent class

3.

What will be the output of this code?

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

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

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

class D(B, C):
    pass

d = D()
d.greet()

medium

A. Hello from B

B. Hello from A

C. Hello from C

D. Hello from D

Solution

1. Step 1: Understand method resolution order (MRO)

   Class D inherits from B and C. Python looks for greet() in D, then B, then C, then A.

2. Step 2: Identify which greet() is called

   D has no greet(), so it calls B's greet() first, printing 'Hello from B'.

3. Final Answer:

   Hello from B -> Option A

4. Quick Check:

   MRO chooses first parent method [OK]

Hint: MRO calls first parent's method in order [OK]

Common Mistakes:

• Assuming C's greet() is called
• Expecting A's greet() to run
• Thinking D has greet() method

4.

Find the error in this code related to the diamond problem:

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

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

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

class D(B, C):
    def greet(self):
        C.greet(self)

D().greet()

medium

A. Calling C.greet(self) ignores B's greet and breaks MRO.

B. Missing super() call causes infinite recursion.

C. Syntax error in class D definition.

D. No error; code runs fine.

Solution

1. Step 1: Analyze method call in D.greet()

   D.greet() calls C.greet(self) directly, skipping B's greet() and ignoring MRO.

2. Step 2: Understand diamond problem and MRO importance

   By calling C.greet(self) directly, it breaks the expected MRO chain and can cause unexpected behavior.

3. Final Answer:

   Calling C.greet(self) ignores B's greet and breaks MRO. -> Option A

4. Quick Check:

   Direct base class call breaks MRO [OK]

Hint: Avoid direct base class calls; use super() to respect MRO [OK]

Common Mistakes:

• Thinking code has syntax error
• Missing that direct call breaks MRO
• Assuming no error occurs

5.

Given this class structure, what will be the output of D().greet()?

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

class B(A):
    def greet(self):
        print('Hello from B')
        super().greet()

class C(A):
    def greet(self):
        print('Hello from C')
        super().greet()

class D(B, C):
    def greet(self):
        print('Hello from D')
        super().greet()

D().greet()

hard

A. Hello from D
Hello from C
Hello from A

B. Hello from D
Hello from C
Hello from B
Hello from A

C. Hello from D
Hello from B
Hello from A

D. Hello from D
Hello from B
Hello from C
Hello from A

Solution

1. Step 1: Determine MRO for class D

   D's MRO is D, B, C, A, object. super() calls follow this order.

2. Step 2: Trace greet() calls

   D.greet() prints 'Hello from D' then calls B.greet(), which prints 'Hello from B' and calls C.greet(), which prints 'Hello from C' and calls A.greet(), which prints 'Hello from A'.

3. Final Answer:

   Hello from D Hello from B Hello from C Hello from A -> Option D

4. Quick Check:

   super() follows MRO chain [OK]

Hint: super() calls follow MRO order in diamond inheritance [OK]

Common Mistakes:

• Ignoring MRO order in super() calls
• Assuming C's greet() runs before B's
• Missing that all greet() methods run