Multiple Inheritance in Python (With Examples)

In object-oriented programming, inheritance is a fundamental concept that allows a class to inherit properties and behaviors from another class. Python, being an object-oriented programming language, supports multiple inheritance, which means a class can inherit from multiple parent classes. This feature enables developers to create complex class hierarchies and share functionalities across various classes. In this tutorial, we will explore the concept of multiple inheritance in Python through detailed explanations and examples.

Table of Contents

1. Introduction to Multiple Inheritance
2. Method Resolution Order (MRO)
3. Using super() with Multiple Inheritance
4. Diamond Problem and Resolution
5. Examples of Multiple Inheritance

• Example 1: Creating a Multiple Inheritance Scenario
• Example 2: Simulating Real-world Scenarios

1. Introduction to Multiple Inheritance

In Python, a class can inherit from multiple parent classes. This allows the derived class (also known as a subclass) to inherit attributes and methods from all of its parent classes. This feature promotes code reusability and enables the creation of versatile and complex class hierarchies.

When a class inherits from multiple classes, it inherits both attributes and methods. However, there can be situations where naming conflicts or ambiguity arise due to multiple inheritance. Python addresses this by using a method resolution order (MRO) mechanism to determine the order in which the base classes are considered during method lookup.

2. Method Resolution Order (MRO)

The Method Resolution Order (MRO) is crucial when dealing with multiple inheritance. It defines the sequence in which Python searches for methods and attributes in a class hierarchy. The MRO is determined using the C3 Linearization algorithm, which maintains a consistent and predictable order.

To view the MRO of a class, you can use the mro() method or the .__mro__ attribute. For instance, if you have a class Derived that inherits from multiple parent classes, you can obtain its MRO by calling Derived.mro() or accessing Derived.__mro__.

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

print(D.mro())  # Output: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

3. Using super() with Multiple Inheritance

The super() function plays a vital role in managing multiple inheritance scenarios. It allows you to call a method from a parent class in a way that respects the MRO. By using super(), you ensure that the method from the appropriate parent class is invoked.

Here’s how you can use super() in a multiple inheritance scenario:

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        super().show()
        print("B")

class C(A):
    def show(self):
        super().show()
        print("C")

class D(B, C):
    def show(self):
        super().show()
        print("D")

obj = D()
obj.show()

In this example, the super().show() calls ensure that the methods from classes A, B, and C are invoked in the correct order, respecting the MRO.

4. Diamond Problem and Resolution

The diamond problem is a classic issue that arises in languages with multiple inheritance, where a class inherits from two classes that have a common base class. This can lead to ambiguity in method resolution. Python’s MRO mechanism helps in resolving the diamond problem by maintaining a consistent order for method lookup.

Consider the following example:

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

obj = D()
obj.show()

In this scenario, class D inherits from both B and C, which in turn inherit from A. When obj.show() is called, Python follows the MRO to determine that the method from class B is invoked. This is because D(B, C) leads to the MRO [D, B, C, A], so the method from class B takes precedence.

5. Examples of Multiple Inheritance

Example 1: Creating a Multiple Inheritance Scenario

Let’s consider a practical example involving multiple inheritance. We’ll create a class hierarchy for vehicles, focusing on common attributes and methods shared by different types of vehicles.

class Engine:
    def start(self):
        print("Engine started")

    def stop(self):
        print("Engine stopped")

class Electric:
    def charge(self):
        print("Charging")

class Car(Engine, Electric):
    def drive(self):
        print("Car is being driven")

class Plane(Engine):
    def fly(self):
        print("Plane is flying")

car = Car()
car.start()
car.charge()
car.drive()
car.stop()

plane = Plane()
plane.start()
plane.fly()
plane.stop()

In this example, the Car class inherits from both Engine and Electric. The Plane class inherits only from Engine. The MRO ensures that the appropriate methods are invoked when objects of these classes call their respective methods.

Example 2: Simulating Real-world Scenarios

Imagine you’re creating a game that involves various characters with different abilities. Multiple inheritance can help model these characters efficiently.

class Ability:
    def activate(self):
        pass

class FlyingAbility(Ability):
    def activate(self):
        print("Character is flying")

class ShootingAbility(Ability):
    def activate(self):
        print("Character is shooting")

class Character:
    def __init__(self, name):
        self.name = name
        self.abilities = []

    def add_ability(self, ability):
        self.abilities.append(ability)

    def use_abilities(self):
        for ability in self.abilities:
            ability.activate()

class FlyingShooter(Character):
    def __init__(self, name):
        super().__init__(name)
        self.add_ability(FlyingAbility())
        self.add_ability(ShootingAbility())

class GroundShooter(Character):
    def __init__(self, name):
        super().__init__(name)
        self.add_ability(ShootingAbility())

fly_shoot_char = FlyingShooter("Aerial Sniper")
ground_shoot_char = GroundShooter("Ground Trooper")

fly_shoot_char.use_abilities()
ground_shoot_char.use_abilities()

In this example, we have classes representing different abilities and characters. The Character class uses multiple inheritance to incorporate various abilities. By creating subclasses like FlyingShooter and GroundShooter, we can easily model characters with specific sets of abilities.

Conclusion

Multiple inheritance in Python allows you to create intricate class hierarchies by inheriting attributes and methods from multiple parent classes. The method resolution order (MRO) ensures that method lookup is consistent and predictable, mitigating issues like the diamond problem. By utilizing the

super() function and proper design, you can manage multiple inheritance scenarios effectively. This powerful feature can be used to model complex real-world scenarios, promoting code reusability and maintainability in your projects.