What is Inheritance in Python? Concepts and Examples

Inheritance in Python enables a new class (child or derived class) to inherit attributes and methods from an existing class (parent or base class). This means you can define common functionality in a parent class and extend or customise it in child classes without rewriting code.

Example:

 
            class Animal:
            def speak(self):
            return "Animal speaks"

            class Dog(Animal):
            def bark(self):
            return "Dog barks"
             

Here, the Dog class inherits the speak() method from Animal, while also introducing its method bark().

Understanding what inheritance is in Python with example is critical for building efficient object-oriented programs that scale well over time.

Python supports a dynamic and flexible model of inheritance, making it easier for developers to build upon existing code. The basic form of inheritance is single inheritance, where a child class inherits from one parent class. The super() function is often used to refer to the parent class and invoke its methods.

Syntax:

 
            class Parent:
            def show(self):
            print("Parent method")

            class Child(Parent):
            def display(self):
            print("Child method")
               

Why Use Inheritance?

Read More:

Beginner's Guide To Python

Essential Python Interview Questions & Answers

Understanding the various types of inheritance is crucial for writing efficient OOP-based Python code. Each has its own advantages and ideal use cases.

Single Inheritance

This is the simplest form, where one child class inherits from one parent class.

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

            class Car(Vehicle):
            def drive(self):
            print("Car is driving")
             

Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one base class.

 
            class Father:
            def skills(self):
            print("Gardening and Programming")

            class Mother:
            def skills(self):
            print("Cooking and Art")

            class Child(Father, Mother):
            pass

            c = Child()
            c.skills() # Output depends on method resolution order (MRO)
           

If you're wondering what multiple inheritance is in Python, it is a powerful but potentially confusing feature due to the complexity introduced by method resolution order.

Multilevel Inheritance

In this structure, a class inherits from a derived class, forming a chain.

 
            class Grandparent:
            def legacy(self):
            print("Legacy from grandparent")

            class Parent(Grandparent):
            pass

            class Child(Parent):
            pass
             

Hierarchical Inheritance

Multiple child classes inherit from a single parent class.

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

            class Cat(Animal):
            def meow(self):
            print("Meow")

            class Dog(Animal):
            def bark(self):
            print("Bark")
             

Hybrid Inheritance

This combines two or more types of inheritance, which can lead to ambiguity. Python handles this using the C3 Linearization or Method Resolution Order (MRO).

Which Inheritance is Not Supported in Python?

Private inheritance, common in languages like C++, is not supported in Python. However, naming conventions (prefixing attributes with an underscore or double underscore) provide some level of privacy and protection.

While inheritance is powerful, it comes with potential pitfalls:

Python also supports advanced inheritance mechanisms that offer more flexibility:

Using super()

The super() function provides a cleaner way to call parent class methods, especially in multiple inheritance scenarios. When implementing quick transformations or filtering operations within class methods, you can efficiently use lambda functions in class methods for concise, readable code.

 
            class A:
            def __init__(self):
            print("A init")

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

Dynamic Inheritance

Classes can be created dynamically using the type() function or metaclasses, offering greater flexibility in large applications. To add additional functionality to inherited methods without modifying the original class, you can combine inheritance with Python decorators for method enhancement.

Inheritance in Python is a cornerstone of writing modular, scalable, and reusable code in object-oriented programming. Before diving into advanced OOP concepts like inheritance, make sure you have a solid foundation in essential Python concepts for beginners including variables, functions, and basic data structures. From understanding what is inheritance in Python with examples to exploring what is multiple inheritance in Python, it’s important to know both the benefits and limitations of this feature. If you're asking which inheritance is not supported in Python, remember that while Python lacks access specifiers like private or protected inheritance, it provides alternative design patterns for control.

Whether you're a beginner working on simple class structures or an advanced developer building complex hierarchies, mastering inheritance is essential for efficient Python programming.

What is inheritance in Python with an example?

Inheritance in Python allows one class (child) to inherit methods and attributes from another (parent). This promotes code reuse and logical hierarchy. For example:

 
            class Animal:
            def speak(self):
            return "Sound"

            class Dog(Animal):
            pass
             

Here, Dog inherits the speak() method from Animal.

What is inheritance, and examples?

Inheritance is an object-oriented programming concept where a class derives properties and methods from another class. It supports reusability and hierarchical class relationships. For instance, a Car class can inherit from a Vehicle class, thereby gaining attributes such as speed and fuel type. Python supports single, multiple, and multilevel inheritance, enabling developers to build flexible and maintainable code structures.

What are the types of inheritance in Python?

Python supports five main types of inheritance:

What is the difference between single and multiple inheritance in Python?

Single inheritance allows a child class to inherit from one parent class, offering a simple and clear hierarchy. Multiple inheritance enables a child class to inherit from multiple parent classes, providing more flexibility but also increasing complexity due to potential method resolution conflicts. Python handles such conflicts using the Method Resolution Order (MRO) mechanism.

How do you implement inheritance in Python?

To implement inheritance in Python, define a parent class and then create a child class that references it in parentheses. The child class gains access to the parent’s attributes and methods. Example:

 
            class Parent:
            def greet(self):
            return "Hello"

            class Child(Parent):
            pass
            

Here, Child inherits the greet() method from Parent.

What are the benefits of using inheritance in Python?

Inheritance in Python enhances code reusability, reduces redundancy, and simplifies maintenance. It supports logical data modeling through class hierarchies and promotes clean code architecture. Inheritance also facilitates polymorphism and scalability, making it easier to implement changes in a centralised manner across multiple derived classes without repeatedly altering shared functionality.