Best practices for multiple inheritance in Python - Step-by-Step Execution

Concept Flow - Best practices for multiple inheritance

Define Base Classes

↓

Create Child Class with Multiple Parents

↓

Use super() to call parent methods

↓

Follow Method Resolution Order (MRO)

↓

Avoid Diamond Problem by using super()

↓

Test Child Class Behavior

↓

Maintain Clear, Simple Hierarchy

This flow shows how to define multiple parent classes, create a child class using them, use super() to manage method calls, follow Python's method resolution order, avoid common problems, and test the final behavior.

Execution Sample

Python

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

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

class C(A, B):
    def greet(self):
        super().greet()

This code defines two parent classes A and B with greet methods, then a child class C that inherits from both and calls super().greet() to follow MRO.

Execution Table

Step	Action	Class/Method Called	MRO Used	Output
1	Create instance c of class C	C.__init__	C -> A -> B -> object
2	Call c.greet()	C.greet	C -> A -> B -> object
3	Inside C.greet(), call super().greet()	A.greet	C -> A -> B -> object	Hello from A
4	No further super() call, method ends	-	-	-
5	Execution ends	-	-	-

💡 Method resolution order ends after calling A.greet(), no further super() calls.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
c	undefined	instance of C	instance of C	instance of C	instance of C

Key Moments - 3 Insights

Why does super() call A.greet() and not B.greet() in class C?

Because Python follows the Method Resolution Order (MRO) which is C -> A -> B -> object. The super() call in C.greet() calls the next method in this order, which is A.greet(), as shown in execution_table step 3.

What happens if we don't use super() in multiple inheritance?

Without super(), parent methods might not be called properly, leading to skipped behavior or duplicated code. Using super() ensures the MRO is followed and all relevant methods are called, as demonstrated in the execution_table.

How does Python avoid the diamond problem with super()?

Python's MRO and super() work together to call each method only once in the correct order, preventing repeated calls from multiple inheritance paths. This is why in the execution_table, each method is called once following the MRO.

Visual Quiz - 3 Questions

Look at the execution_table, which class's greet method is called by super() inside C.greet()?

A B.greet

B A.greet

C C.greet

D object.greet

💡 Hint

Refer to execution_table step 3 where super().greet() calls A.greet() following MRO.

At which step does the program output 'Hello from A'?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Check execution_table output column; 'Hello from A' appears at step 3.

If class C inherited as class C(B, A) instead, which greet method would super() call first?

A B.greet

B C.greet

C A.greet

D object.greet

💡 Hint

MRO depends on inheritance order; changing to C(B, A) makes B first after C.

Concept Snapshot

Multiple inheritance lets a class inherit from many parents.
Use super() to call parent methods safely.
Python uses Method Resolution Order (MRO) to decide call order.
Always follow MRO to avoid bugs like diamond problem.
Keep inheritance simple and test behavior carefully.

Full Transcript

This lesson shows best practices for multiple inheritance in Python. We start by defining two parent classes A and B, each with a greet method. Then we create a child class C that inherits from both A and B. Inside C's greet method, we use super().greet() to call the next method in the method resolution order (MRO). The MRO for class C is C, then A, then B, then object. When we call c.greet(), it runs C.greet(), which calls A.greet() via super(). This ensures the correct method is called without duplication or skipping. Using super() and understanding MRO helps avoid common problems like the diamond problem. The execution table traces each step, showing method calls and outputs. Key moments clarify why super() calls A.greet() and how Python manages multiple inheritance safely. The visual quiz tests understanding of MRO and method calls. The snapshot summarizes the main points for quick review.

Practice

1.

What is the main reason to use super() in multiple inheritance?

easy

A. To create a new instance of the child class

B. To call only the first parent class method

C. To avoid using any parent class methods

D. To ensure all parent classes are properly initialized

Solution

1. Step 1: Understand the role of super() in multiple inheritance

   super() helps call the next method in the method resolution order (MRO), ensuring all parent classes get initialized properly.

2. Step 2: Recognize why this is important

   Without super(), some parent classes might be skipped, causing incomplete initialization.

3. Final Answer:

   To ensure all parent classes are properly initialized -> Option D

4. Quick Check:

   Use super() to call all parents [OK]

Hint: Use super() to call all parents in order [OK]

Common Mistakes:

• Calling only one parent class directly
• Not using super() causing skipped initializations
• Confusing super() with creating new instances

2.

Which of the following is the correct syntax to define a class Child inheriting from Parent1 and Parent2?

?

easy

A. class Child: Parent1, Parent2

B. class Child(Parent1, Parent2):

C. class Child inherits Parent1, Parent2:

D. class Child(Parent1 & Parent2):

Solution

1. Step 1: Recall Python class inheritance syntax

   In Python, multiple inheritance is declared by listing parent classes inside parentheses separated by commas.

2. Step 2: Match the correct syntax

   class Child(Parent1, Parent2): uses class Child(Parent1, Parent2):, which is the correct Python syntax.

3. Final Answer:

   class Child(Parent1, Parent2): -> Option B

4. Quick Check:

   Use parentheses with commas for multiple inheritance [OK]

Hint: Use parentheses with commas for multiple parents [OK]

Common Mistakes:

• Using incorrect keywords like 'inherits'
• Using '&' instead of commas
• Placing parents outside parentheses

3.

What will be the output of the following code?

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 = D()
d.greet()

medium

A. Hello from D
Hello from B
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 C
Hello from A

Solution

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

   For class D(B, C), the MRO is D > B > C > A. Calling super() follows this order.

2. Step 2: Trace the calls

   d.greet() prints 'Hello from D', then calls B.greet() which prints 'Hello from B' and calls C.greet(). C.greet() 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 A

4. Quick Check:

   MRO order = D, B, C, A [OK]

Hint: Follow MRO order when super() is called [OK]

Common Mistakes:

• Ignoring MRO and calling parents in wrong order
• Assuming super() calls only immediate parent
• Missing one of the parent class prints

4.

Identify the error in the following code snippet using multiple inheritance:

class X:
    def __init__(self):
        print('X init')

class Y:
    def __init__(self):
        print('Y init')

class Z(X, Y):
    def __init__(self):
        X.__init__(self)
        Y.__init__(self)

z = Z()

medium

A. Class Z should inherit only from one parent

B. Missing call to super().__init__() in class Z

C. Directly calling parent __init__ methods can cause problems in complex hierarchies

D. No error, code runs fine

Solution

1. Step 1: Analyze direct calls to parent __init__ methods

   Calling X.__init__(self) and Y.__init__(self) directly bypasses Python's MRO and can cause issues if the hierarchy grows complex.

2. Step 2: Understand best practice

   Using super().__init__() respects MRO and avoids duplicate or missed calls.

3. Final Answer:

   Directly calling parent __init__ methods can cause problems in complex hierarchies -> Option C

4. Quick Check:

   Use super() to avoid init call issues [OK]

Hint: Avoid direct parent calls; use super() instead [OK]

Common Mistakes:

• Thinking direct calls are always safe
• Ignoring MRO and its importance
• Believing multiple inheritance requires single parent only

5.

You want to create a class SmartPhone that inherits features from Camera and Phone. Both parents have an __init__ method. How should you design SmartPhone to properly initialize both parents following best practices?

hard

A. Define SmartPhone.__init__ and call super().__init__() only once, relying on parents to use super() too

B. Define SmartPhone.__init__ but leave it empty

C. Do not define __init__ in SmartPhone, parents will initialize automatically

D. Define SmartPhone.__init__ and call Camera.__init__(self) and Phone.__init__(self) directly

Solution

1. Step 1: Understand multiple inheritance initialization

   Both Camera and Phone have __init__. To initialize both properly, each class should call super().__init__() so the MRO chain is followed.

2. Step 2: Apply best practice in SmartPhone

   Define SmartPhone.__init__ and call super().__init__() once. This triggers the chain of __init__ calls in parents via MRO.

3. Final Answer:

   Define SmartPhone.__init__ and call super().__init__() only once, relying on parents to use super() too -> Option A

4. Quick Check:

   Use super() chain for clean multiple inheritance init [OK]

Hint: Call super().__init__() once; parents must do the same [OK]

Common Mistakes:

• Calling parent __init__ methods directly
• Not calling any __init__ in child
• Assuming parents initialize automatically without super()