Best practices for multiple inheritance in Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a class that inherits from two parent classes.

Python

class Child([1]):
    pass

Drag options to blanks, or click blank then click option'

AParent1, Parent2

BParent1 Parent2

CParent1 & Parent2

DParent1 | Parent2

Attempts:

3 left

💡 Hint

Common Mistakes

Using spaces instead of commas between parent classes.

Using operators like & or | which are invalid here.

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

2fill in blank

medium

Complete the code to call the __init__ method of the first parent class in multiple inheritance.

Python

class Child(Parent1, Parent2):
    def __init__(self):
        [1].__init__(self)

Drag options to blanks, or click blank then click option'

Asuper()

BParent1

CChild

DParent2

Attempts:

3 left

💡 Hint

Common Mistakes

Using super() when wanting to call a specific parent's __init__.

Calling __init__ on the child class itself.

To call a specific parent class's __init__, use Parent1.__init__(self).

3fill in blank

hard

Fix the error in the code to properly use super() in multiple inheritance.

Python

class Child(Parent1, Parent2):
    def __init__(self):
        [1]().__init__()

Drag options to blanks, or click blank then click option'

Aself

BParent1

CChild

Dsuper

Attempts:

3 left

💡 Hint

Common Mistakes

Calling Parent1() instead of super().

Calling __init__ on self directly.

super() returns a proxy object to delegate method calls properly in multiple inheritance.

4fill in blank

hard

Fill both blanks to create a method that calls the same method from all parent classes using super().

Python

class Child(Parent1, Parent2):
    def greet(self):
        [1]().[2]()

Drag options to blanks, or click blank then click option'

Asuper

Bgreet

Chello

Dself

Attempts:

3 left

💡 Hint

Common Mistakes

Using self.greet() which causes recursion.

Using a wrong method name like hello.

Use super().greet() to call the greet method from the next class in the method resolution order.

5fill in blank

hard

Fill all three blanks to create a class that uses super() in __init__ and a method to demonstrate method resolution order.

Python

class Child([1]):
    def __init__(self):
        [2]().__init__()
    def show(self):
        print('Child show')
        [3]().show()

Drag options to blanks, or click blank then click option'

AParent1, Parent2

Bsuper

DParent2

Attempts:

3 left

💡 Hint

Common Mistakes

Not listing both parents in the class definition.

Calling parent methods directly instead of using super().

The class inherits from Parent1 and Parent2. super() is used to call the next __init__ and show methods in the method resolution order.

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()