Multi Level Inheritance in Python (Complete Guide for Beginners)

 Multi Level Inheritance is one of the important inheritance types in Python Object-Oriented Programming (OOP). It occurs when a class inherits from another class, and then a third class inherits from the second class.

This creates a chain of inheritance where properties and methods can be passed through multiple levels.

In this tutorial, you will learn how multilevel inheritance works, its advantages, real-world examples, and best practices.

---

What is Multi Level Inheritance?

Multilevel inheritance is a type of inheritance where a derived class becomes the base class for another class.

Structure

Grandparent
      ↓
   Parent
      ↓
    Child

The child class inherits features from both the parent and grandparent classes.

---

Why Use Multi Level Inheritance?

Multilevel inheritance helps:

• Reuse code efficiently
• Reduce duplication
• Create logical class hierarchies
• Improve code organization
• Build scalable applications

---

Basic Syntax

class GrandParent:
    pass

class Parent(GrandParent):
    pass

class Child(Parent):
    pass

The Child class inherits from Parent, and indirectly inherits from GrandParent.

---

Simple Multi Level Inheritance Example

class Animal:

    def eat(self):
        print("Animal can eat")

class Dog(Animal):

    def bark(self):
        print("Dog can bark")

class Puppy(Dog):

    def weep(self):
        print("Puppy can weep")

puppy = Puppy()

puppy.eat()
puppy.bark()
puppy.weep()

Output

Animal can eat
Dog can bark
Puppy can weep

---

Understanding the Inheritance Chain

In the previous example:

Animal
   ↓
 Dog
   ↓
Puppy

The Puppy class can access:

• eat() from Animal
• bark() from Dog
• weep() from Puppy

---

Multi Level Inheritance with Attributes

class Person:

    def __init__(self):
        self.name = "John"

class Employee(Person):

    def __init__(self):
        super().__init__()
        self.department = "IT"

class Manager(Employee):

    def __init__(self):
        super().__init__()
        self.position = "Manager"

manager = Manager()

print(manager.name)
print(manager.department)
print(manager.position)

Output

John
IT
Manager

---

Using Constructors in Multi Level Inheritance

Constructors can be inherited through multiple levels using super().

Example

class A:

    def __init__(self):
        print("Class A Constructor")

class B(A):

    def __init__(self):
        super().__init__()
        print("Class B Constructor")

class C(B):

    def __init__(self):
        super().__init__()
        print("Class C Constructor")

obj = C()

Output

Class A Constructor
Class B Constructor
Class C Constructor

---

Using super() in Multi Level Inheritance

The super() function allows a child class to access methods and constructors from its parent class.

Example

class Vehicle:

    def start(self):
        print("Vehicle Started")

class Car(Vehicle):

    def drive(self):
        print("Car Driving")

class SportsCar(Car):

    def race(self):
        print("Sports Car Racing")

car = SportsCar()

car.start()
car.drive()
car.race()

Output

Vehicle Started
Car Driving
Sports Car Racing

---

Method Overriding in Multi Level Inheritance

A child class can override methods inherited from parent classes.

Example

class Animal:

    def sound(self):
        print("Animal Sound")

class Dog(Animal):

    def sound(self):
        print("Bark")

class Puppy(Dog):
    pass

puppy = Puppy()

puppy.sound()

Output

Bark

Python uses the nearest overridden method.

---

Real-World Example: Educational System

class Person:

    def show_name(self):
        print("Person Information")

class Student(Person):

    def show_course(self):
        print("Python Course")

class GraduateStudent(Student):

    def show_research(self):
        print("Research Project")

student = GraduateStudent()

student.show_name()
student.show_course()
student.show_research()

Output

Person Information
Python Course
Research Project

---

Real-World Example: Banking System

class Account:

    def create_account(self):
        print("Account Created")

class SavingsAccount(Account):

    def deposit(self):
        print("Money Deposited")

class PremiumSavings(SavingsAccount):

    def get_rewards(self):
        print("Rewards Added")

customer = PremiumSavings()

customer.create_account()
customer.deposit()
customer.get_rewards()

---

Real-World Example: Employee Hierarchy

class Employee:

    def work(self):
        print("Employee Working")

class TeamLeader(Employee):

    def lead(self):
        print("Leading Team")

class ProjectManager(TeamLeader):

    def manage(self):
        print("Managing Project")

pm = ProjectManager()

pm.work()
pm.lead()
pm.manage()

Output

Employee Working
Leading Team
Managing Project

---

Checking Multi Level Inheritance

Use issubclass().

class A:
    pass

class B(A):
    pass

class C(B):
    pass

print(issubclass(C, A))

Output

True

---

Checking Object Types

Use isinstance().

class A:
    pass

class B(A):
    pass

class C(B):
    pass

obj = C()

print(isinstance(obj, C))
print(isinstance(obj, B))
print(isinstance(obj, A))

Output

True
True
True

---

Advantages of Multi Level Inheritance

1. Code Reusability

Write code once and reuse it across multiple levels.

2. Easy Maintenance

Changes in parent classes automatically affect child classes.

3. Logical Structure

Represents real-world relationships naturally.

4. Reduced Duplication

Avoids rewriting methods and attributes.

---

Disadvantages of Multi Level Inheritance

1. Increased Complexity

Deep inheritance chains may become difficult to understand.

2. Debugging Difficulty

Finding method origins can take more time.

3. Tight Coupling

Changes in parent classes can affect many child classes.

---

Multi Level Inheritance vs Single Inheritance

Feature	Single Inheritance	Multi Level Inheritance
Levels	One Parent	Multiple Levels
Complexity	Low	Moderate
Reusability	Good	Excellent
Maintenance	Easy	More Complex

---

Common Mistakes

Mistake 1: Forgetting super()

❌ Wrong

class Child(Parent):

    def __init__(self):
        pass

✔ Correct

class Child(Parent):

    def __init__(self):
        super().__init__()

---

Mistake 2: Deep Inheritance Trees

Avoid creating very long inheritance chains.

A → B → C → D → E → F → G

This becomes difficult to manage.

---

Mistake 3: Unnecessary Inheritance

Use inheritance only when there is a true "is-a" relationship.

---

Best Practices

• Keep inheritance hierarchies simple.
• Use super() to access parent functionality.
• Avoid excessive inheritance levels.
• Use meaningful class names.
• Favor composition when inheritance becomes too complex.

---

Multi Level Inheritance Summary

Concept	Description
Grandparent Class	Top-level class
Parent Class	Inherits from grandparent
Child Class	Inherits from parent
super()	Calls parent methods
Method Overriding	Replaces inherited methods
issubclass()	Checks inheritance
isinstance()	Checks object type

---

Conclusion

Multi Level Inheritance is a powerful OOP feature that allows classes to inherit functionality through multiple levels.

You learned:

• What multilevel inheritance is
• How inheritance chains work
• Using constructors and super()
• Method overriding
• Real-world examples
• Advantages and disadvantages
• Best practices

Mastering multilevel inheritance will help you build well-structured, scalable, and reusable Python applications.

---

Practice Exercises

Exercise 1

Create three classes:

• Animal
• Dog
• Puppy

Use multilevel inheritance and demonstrate method access.

---

Exercise 2

Create:

• Person
• Employee
• Manager

Store and display employee information.

---

Exercise 3

Create:

• Vehicle
• Car
• SportsCar

Add unique methods at each level and call them from the final class.