Why multiple inheritance exists in Python - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use multiple inheritance in Python?

Why does Python support multiple inheritance?

A To prevent any class from inheriting methods or properties.

B To force a class to have only one parent class to avoid complexity.

C To make sure classes cannot share any attributes.

D To allow a class to inherit features from more than one parent class, enabling code reuse and combining behaviors.

💡 Hint

Think about how combining features from different sources can help in programming.

Multiple inheritance lets a class use methods and properties from multiple parent classes. This helps reuse code and combine different behaviors in one class.

❓ Predict Output

intermediate

Output of multiple inheritance example

What is the output of this Python code?

Python

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

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

class C(A, B):
    pass

obj = C()
print(obj.greet())

A Hello from B

B Hello from A

C Hello from C

D TypeError

💡 Hint

Look at the order of inheritance in class C and how Python resolves method calls.

Python uses the method resolution order (MRO). Since class A is listed first in C(A, B), its greet method is called.

❓ Predict Output

advanced

Understanding method resolution order (MRO)

What will be printed by this code?

Python

class X:
    def who(self):
        return 'X'

class Y(X):
    def who(self):
        return 'Y'

class Z(X):
    def who(self):
        return 'Z'

class A(Y, Z):
    pass

obj = A()
print(obj.who())

A Z

B X

C Y

D TypeError

💡 Hint

Check the order of classes in A(Y, Z) and how Python chooses methods.

Python uses MRO and checks Y before Z, so Y's who method is called.

🧠 Conceptual

advanced

Why might multiple inheritance cause problems?

What is a common problem caused by multiple inheritance?

A It can cause ambiguity when two parent classes have methods with the same name.

B It always makes programs run slower.

C It prevents any code reuse.

D It disallows creating new classes.

💡 Hint

Think about what happens if two parents have the same method name.

Multiple inheritance can cause ambiguity if parent classes have methods with the same name, making it unclear which method to use.

🚀 Application

expert

Predict the output with diamond inheritance

What will this code print?

Python

class Base:
    def greet(self):
        return 'Hello from Base'

class Left(Base):
    def greet(self):
        return 'Hello from Left'

class Right(Base):
    def greet(self):
        return 'Hello from Right'

class Child(Left, Right):
    pass

obj = Child()
print(obj.greet())

A Hello from Left

B Hello from Right

C Hello from Base

D TypeError

💡 Hint

Consider the diamond shape of inheritance and Python's MRO.

Python uses MRO and checks Left before Right, so Left's greet method is called.