Python - Multiple Inheritance (Complete Guide for Beginners)

 Multiple Inheritance is an advanced Object-Oriented Programming (OOP) feature in Python that allows a class to inherit attributes and methods from more than one parent class.

This feature enables code reuse from multiple sources and helps create flexible class hierarchies. Python fully supports multiple inheritance, making it more powerful than many other programming languages.

In this tutorial, you will learn how multiple inheritance works, its advantages, potential issues, and best practices.

---

What is Multiple Inheritance?

Multiple inheritance occurs when a child class inherits from two or more parent classes.

Syntax

class Parent1:
    pass

class Parent2:
    pass

class Child(Parent1, Parent2):
    pass

The child class can access methods and attributes from both parent classes.

---

Why Use Multiple Inheritance?

Multiple inheritance allows you to:

• Reuse code from multiple classes
• Combine functionalities
• Reduce code duplication
• Build modular applications
• Create flexible class structures

---

Basic Multiple Inheritance Example

class Father:

    def drive(self):
        print("Father can drive")

class Mother:

    def cook(self):
        print("Mother can cook")

class Child(Father, Mother):
    pass

child = Child()

child.drive()
child.cook()

Output

Father can drive
Mother can cook

The Child class inherited methods from both Father and Mother.

---

Multiple Inheritance with Attributes

A child class can inherit attributes from multiple parent classes.

Example

class Father:

    def __init__(self):
        self.car = "Toyota"

class Mother:

    def __init__(self):
        self.house = "Family House"

class Child(Father, Mother):
    pass

This example introduces an important topic: constructors.

---

Constructor Problem in Multiple Inheritance

Consider the following code:

class Father:

    def __init__(self):
        print("Father Constructor")

class Mother:

    def __init__(self):
        print("Mother Constructor")

class Child(Father, Mother):
    pass

child = Child()

Output

Father Constructor

Only the first parent constructor executes automatically.

---

Calling Multiple Parent Constructors

Example

class Father:

    def __init__(self):
        print("Father Constructor")

class Mother:

    def __init__(self):
        print("Mother Constructor")

class Child(Father, Mother):

    def __init__(self):
        Father.__init__(self)
        Mother.__init__(self)

child = Child()

Output

Father Constructor
Mother Constructor

Now both constructors run successfully.

---

Real-World Example: Smart Device

class Camera:

    def take_photo(self):
        print("Photo Captured")

class Phone:

    def make_call(self):
        print("Calling...")

class SmartPhone(Camera, Phone):
    pass

phone = SmartPhone()

phone.take_photo()
phone.make_call()

Output

Photo Captured
Calling...

A smartphone combines features of both a camera and a phone.

---

Real-World Example: Employee Skills

class Programmer:

    def code(self):
        print("Writing Code")

class Designer:

    def design(self):
        print("Creating Designs")

class FullStackDeveloper(Programmer, Designer):
    pass

developer = FullStackDeveloper()

developer.code()
developer.design()

Output

Writing Code
Creating Designs

---

Method Resolution Order (MRO)

When multiple parent classes contain methods with the same name, Python follows a specific order to determine which method to execute.

This order is called the Method Resolution Order (MRO).

---

MRO Example

class A:

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

class B:

    def show(self):
        print("Class B")

class C(A, B):
    pass

obj = C()

obj.show()

Output

Class A

Python searches parent classes from left to right.

---

Checking MRO

Use the mro() method.

Example

class A:
    pass

class B:
    pass

class C(A, B):
    pass

print(C.mro())

Output

[<class '__main__.C'>,
 <class '__main__.A'>,
 <class '__main__.B'>,
 <class 'object'>]

---

Diamond Problem

The Diamond Problem occurs when multiple classes inherit from the same parent.

Structure

       A
      / \
     B   C
      \ /
       D

---

Diamond Problem Example

class A:

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

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

obj = D()

obj.show()

Output

Class A

Python uses MRO to avoid duplicate method calls.

---

Understanding super() in Multiple Inheritance

The super() function helps Python follow the MRO correctly.

Example

class A:

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

class B(A):

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

class C(B):

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

obj = C()

obj.show()

Output

C
B
A

---

Practical Example: Smart Home System

class SecuritySystem:

    def secure(self):
        print("Home Secured")

class LightingSystem:

    def lights_on(self):
        print("Lights Turned On")

class SmartHome(SecuritySystem, LightingSystem):
    pass

home = SmartHome()

home.secure()
home.lights_on()

---

Practical Example: Online Learning Platform

class VideoCourse:

    def play_video(self):
        print("Playing Video")

class QuizCourse:

    def start_quiz(self):
        print("Starting Quiz")

class CompleteCourse(VideoCourse, QuizCourse):
    pass

course = CompleteCourse()

course.play_video()
course.start_quiz()

---

Advantages of Multiple Inheritance

1. Code Reusability

Reuse functionality from multiple classes.

2. Flexibility

Combine different features into one class.

3. Reduced Duplication

Avoid writing the same code multiple times.

4. Better Organization

Separate functionality into smaller classes.

---

Disadvantages of Multiple Inheritance

1. Increased Complexity

Class hierarchies become harder to understand.

2. Method Conflicts

Methods with the same name can cause confusion.

3. Debugging Challenges

Tracking inherited methods may be difficult.

4. Diamond Problem

Complex inheritance structures can become difficult to maintain.

---

Best Practices

• Use multiple inheritance only when necessary.
• Keep parent classes focused on specific tasks.
• Use super() whenever possible.
• Understand MRO before designing class hierarchies.
• Avoid deeply nested inheritance structures.

---

Multiple Inheritance vs Single Inheritance

Feature	Single Inheritance	Multiple Inheritance
Parent Classes	One	Multiple
Complexity	Low	Higher
Flexibility	Limited	High
Code Reuse	Moderate	Excellent
Maintenance	Easier	More Challenging

---

Common Mistakes

Mistake 1: Ignoring MRO

class A:
    pass

class B:
    pass

class C(A, B):
    pass

Always understand which parent method will be called first.

---

Mistake 2: Duplicate Method Names

Having identical method names in multiple parents can create unexpected behavior.

---

Mistake 3: Not Using super()

Using direct parent calls may bypass MRO and create maintenance issues.

---

Multiple Inheritance Summary

Concept	Description
Multiple Inheritance	Inherit from multiple parents
MRO	Method Resolution Order
super()	Calls next class in MRO
Diamond Problem	Shared ancestor inheritance issue
mro()	Displays inheritance order

---

Conclusion

Multiple inheritance is a powerful Python OOP feature that allows a class to inherit functionality from multiple parent classes.

You learned:

• What multiple inheritance is
• How to create multiple inheritance structures
• Method Resolution Order (MRO)
• Diamond Problem
• Using super()
• Real-world examples
• Best practices

Understanding multiple inheritance will help you build flexible and reusable Python applications while avoiding common inheritance pitfalls.

---

Practice Exercises

Exercise 1

Create classes Teacher and Researcher. Create a class Professor that inherits from both classes.

---

Exercise 2

Create classes MusicPlayer and VideoPlayer. Create a class MediaPlayer that inherits from both.

---

Exercise 3

Create classes Bird and Flyable. Create a class Eagle that inherits from both and uses methods from each parent.