Master Inheritance in Python 3: Unveiling the Types of Inheritance with Multiple Examples

types of inheritance

In the enchanting world of Python, understanding the concept of inheritance is like unraveling a secret code to building more organized, efficient, and maintainable code. Inheritance empowers you to create new classes that inherit attributes and methods from existing ones, promoting code reuse and extensibility. In this comprehensive guide, we’ll embark on a journey through the realm of inheritance in Python. We’ll explore the various types of inheritance and provide you with multiple real-world examples to illuminate the path. Let’s dive in!

What is Inheritance?

Before delving into the types of inheritance, let’s grasp the core idea. Inheritance is a fundamental Object-Oriented Programming (OOP) concept that allows you to define a new class based on an existing class. The new class inherits attributes and methods from the existing class. This mechanism promotes code reuse and the creation of class hierarchies.

The Types of Inheritance in Python

1. Single Inheritance:

Explanation: In this, a class inherits from only one base class. This creates a linear hierarchy, where each subclass inherits attributes and methods from a single superclass.

Insight: It is the simplest form of inheritance and is often used when you want to model an “is-a” relationship between two classes. For example, a Car is a Vehicle, and this relationship is represented through single inheritance. It promotes code organization and reuse without introducing complexity.

Example: In the provided example, the Car class inherits from the Vehicle class, allowing it to access the start_engine() method defined in the Vehicle class.

# Base class
class Vehicle:
    def start_engine(self):
        print("Engine started")

# Derived class inheriting from Vehicle
class Car(Vehicle):
    def drive(self):
        print("Car is moving")

# Creating an instance of Car
my_car = Car()

# Accessing methods from the base class
my_car.start_engine()  # Output: "Engine started"         # Output: "Car is moving"

2. Multiple Inheritance:

Explanation: This allows a class to inherit attributes and methods from more than one base class. Python supports this feature, enabling a class to inherit from multiple parent classes.

Insight: It can be powerful but can also introduce complexity. It’s useful when you want to combine features from different classes into a single class. Careful design is essential to avoid conflicts or ambiguity when methods or attributes with the same name are inherited from multiple parent classes.

Example: In the provided example, the Robot class inherits from both the Human class and the AI class, gaining the ability to both eat like a human and process data like an AI.

# Base classes
class Human:
    def eat(self):

class AI:
    def compute(self):
        print("Processing data")

# Derived class inheriting from both Human and AI
class Robot(Human, AI):
    def work(self):
        print("Working efficiently")

# Creating an instance of Robot
my_robot = Robot()

# Accessing methods from both base classes      # Output: "Eating"
my_robot.compute()  # Output: "Processing data"     # Output: "Working efficiently"

3. Multilevel Inheritance:

Explanation: It involves a chain of inheritance, where a class derives from a base class, and then another class inherits from it. This forms a hierarchy or sequence of inheritance.

Insight: It allows you to create a structured hierarchy of classes, each building upon the features of the previous one. It’s a way to achieve specialization while maintaining a clear lineage of classes.

Example: In the provided example, the Rectangle class inherits from Polygon, which, in turn, inherits from the base class Shape. This hierarchy models a clear relationship where a Rectangle is a specialized form of a Polygon, and a Polygon is a type of Shape.

# Base class
class Shape:
    def area(self):

# Intermediate class inheriting from Shape
class Polygon(Shape):
    def sides(self):

# Derived class inheriting from Polygon
class Rectangle(Polygon):
    def calculate_area(self, length, width):
        return length * width

# Creating an instance of Rectangle
my_rectangle = Rectangle()

# Accessing methods from the entire hierarchy
my_rectangle.area()   # Accesses Shape's area method
my_rectangle.sides()  # Accesses Polygon's sides method

4. Hybrid Inheritance:

Definition: This is a combination of two or more types of inheritance within a single program or class hierarchy. It often involves the use of multiple inheritance, where a class inherits from more than one base class, and then further extends this hierarchy using single, multiple, or multilevel inheritance.


Consider a scenario where you’re developing a simulation for a zoo management system. You have different types of animals, each represented by a class, and various traits that need to be inherited.

# Base class for all animals
class Animal:
    def __init__(self, name): = name

# Base class for land animals
class LandAnimal(Animal):
    def walk(self):
        print(f"{} is walking")

# Base class for aquatic animals
class AquaticAnimal(Animal):
    def swim(self):
        print(f"{} is swimming")

# Derived class for a specific animal, inheriting from both LandAnimal and AquaticAnimal
class Platypus(LandAnimal, AquaticAnimal):
    def __init__(self, name):

# Creating an instance of Platypus
perry = Platypus("Perry the Platypus")

# Accessing methods from both LandAnimal and AquaticAnimal
perry.walk()  # Output: "Perry the Platypus is walking"
perry.swim()  # Output: "Perry the Platypus is swimming"

In this example, we have a hybrid inheritance scenario. The Platypus class inherits from both LandAnimal and AquaticAnimal, allowing it to access methods from both base classes. This demonstrates the combination of single inheritance (from Animal to LandAnimal and AquaticAnimal) and multiple inheritance (from both LandAnimal and AquaticAnimal to Platypus) within a single hierarchy.

5. Hierarchical Inheritance:

Definition: Hierarchical inheritance is a type of inheritance where multiple derived classes inherit from a single base class. In this hierarchy, a single base class serves as a common ancestor for multiple derived classes, allowing each derived class to share common attributes and methods from the base class while adding their unique features.


Let’s imagine a scenario where you’re building a class hierarchy for different shapes in a graphics library.

# Base class for all shapes
class Shape:
    def __init__(self, name): = name

    def area(self):

# Derived class for a specific shape (e.g., Circle)
class Circle(Shape):
    def __init__(self, name, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

# Derived class for another specific shape (e.g., Rectangle)
class Rectangle(Shape):
    def __init__(self, name, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

# Derived class for yet another specific shape (e.g., Triangle)
class Triangle(Shape):
    def __init__(self, name, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

In this example, we have a hierarchical inheritance scenario. The base class Shape serves as the common ancestor, and multiple derived classes like Circle, Rectangle, and Triangle inherit from it. Each derived class specializes in calculating the area of its respective shape, utilizing the common attributes and methods inherited from the base class.

Hierarchical inheritance allows you to create a structured class hierarchy where different subclasses share common characteristics while having their unique implementations, making it a valuable concept in object-oriented programming.


Real-World Examples

1. GUI Development

Scenario: You’re developing a GUI framework for an application.

OOP Application: Use inheritance to create base classes like Widget and Button. Then, derive specialized classes like CheckBox and RadioButton from them.

2. Employee Hierarchy

Scenario: You’re building an HR system for a large organization.

OOP Application: Create a base Employee class, and then have subclasses like Manager, Engineer, and Salesperson inherit from it. Each subclass can have its unique attributes and methods.

3. Animal Kingdom

Scenario: You’re designing a program to model the animal kingdom.

OOP Application: Establish a base class Animal with common attributes like name and species. Subclasses like Mammal, Reptile, and Bird can inherit from Animal, each with its specific features.

Certainly, let’s explore practical use cases for each type including single, multiple, multilevel, hierarchical, and hybrid inheritance:

Single Inheritance:

Practical Use Case: GUI Framework Development

In GUI framework development, single inheritance plays a crucial role. Consider a scenario where you’re creating a GUI framework for a desktop application. You have a base class called Widget, representing a generic graphical component. Subclasses such as Button, TextBox, and Checkbox can inherit from the Widget class. Each subclass inherits common attributes and methods like positioning and rendering from the base class. This allows for code reusability and consistency across various GUI components, making the framework more maintainable and efficient.

Multiple Inheritance:

Practical Use Case: Creating a Robot with Human and AI Abilities

Imagine you’re building a robot with both human-like capabilities (such as eating) and AI-like functions (such as data processing). In this scenario, multiple inheritance becomes invaluable. You can have a base class Human representing human characteristics and a base class AI for artificial intelligence features. The Robot class can then inherit from both Human and AI. This enables the robot to perform actions like eating and processing data, showcasing the power of combining multiple aspects into a single entity.

Multilevel Inheritance:

Practical Use Case: Modeling Geometric Shapes

In the context of geometric shape modeling, multilevel inheritance offers a structured approach. Begin with a base class Shape that defines fundamental attributes and methods shared by all shapes. Then, create an intermediate class, say Polygon, which inherits from Shape. Finally, derive specific shapes like Rectangle and Triangle from the Polygon class. This hierarchy allows you to organize common properties and behaviors, promoting code reuse while representing the relationships between different shapes effectively.

Hierarchical Inheritance:

Practical Use Case: Building an Employee Management System

In an employee management system, hierarchical inheritance proves valuable. Start with a base class Employee that contains essential attributes such as name, ID, and salary. Then, create multiple derived classes like Manager, Engineer, and Salesperson, each specializing in attributes and methods relevant to their respective roles. All these classes inherit from the common Employee base class, ensuring consistency in employee data while accommodating specific role-related functionalities.

Hybrid Inheritance:

Practical Use Case: Simulating a Zoo Management System

Imagine developing a zoo management system where animals have various characteristics and behaviors. Hybrid inheritance can be applied here. Begin with a base class Animal, which contains general attributes and methods. Create specialized classes like LandAnimal and AquaticAnimal using single inheritance, each inheriting from Animal. Now, introduce a class like Platypus that inherits from both LandAnimal and AquaticAnimal, showcasing the combination of single and multiple inheritance. This approach helps model complex real-world scenarios efficiently.


Inheritance in Python is a powerful tool that enhances code organization and promotes code reuse. Whether it’s single, multiple, or multilevel inheritance, understanding these types and applying them to real-world scenarios empowers you to craft more efficient, maintainable, and extensible code. By mastering the art of inheritance, you open the door to a world of endless possibilities in Python programming. So, go ahead, inherit the knowledge, and create software that stands the test of time!

Also, check out our other playlist Rasa ChatbotInternet of thingsDockerPython ProgrammingMQTTTech News, ESP-IDF etc.
Become a member of our social family on youtube here.
Stay tuned and Happy Learning. ✌🏻😃
Happy tinkering! ❤️🔥

Leave a Reply