Python Inheritance | Components, Usage & Types (+Code Examples)

Inheritance is a cornerstone of object-oriented programming (OOP) that enables a class to derive attributes and methods from another class. In Python, this mechanism facilitates code reuse and the creation of a logical class hierarchy, enhancing the modularity and maintainability of code.

In this article, we will discuss everything you need to know about Python inheritance, its components, types of inheritance in Python, and more, with examples. 

What Is Inheritance In Python?

First things first, a class serves as a blueprint for creating objects, encapsulating data, and the functions that operate on that data. This bundling of data (attributes) and behaviors (methods) allows for the creation of objects with specific properties and functionalities.

Inheritance enables the creation of a new class, known as a child or derived class, that inherits attributes and methods from an existing class, referred to as the parent or base class. This mechanism allows the child class to utilize, extend, or modify the functionalities defined in the parent class, promoting code reuse and logical organization.

Real-World Analogy:

Consider a general blueprint for a vehicle, which includes common features like wheels, an engine, and seats. Specific types of vehicles, such as cars and motorcycles, can be seen as specialized versions of this general blueprint. They inherit common features but also have unique characteristics. In this analogy:

• The general vehicle blueprint represents the parent class.
• The specific vehicles (car, motorcycle) represent child classes that inherit from the parent class.

The "is-a" Relationship:

In OOP, the "is-a" relationship signifies that an object of a child class is also an instance of the parent class. For example, a car "is a" vehicle, and a motorcycle "is a" vehicle. This relationship allows child classes to inherit and, if necessary, override or extend the functionalities of the parent class.

Python Inheritance Syntax

Defining inheritance in Python programming involves specifying the parent class in parentheses when creating the child class. The basic syntax is:

class ParentClass:
    # Parent class code
class ChildClass(ParentClass):
    # Child class code

In this structure:

• ParentClass is the existing class whose attributes and methods are to be inherited.
• ChildClass is the new class that inherits from ParentClass.

The syntax for Python inheritance establishes a relationship where ChildClass inherits the properties and behaviors of ParentClass, allowing for code reuse and logical organization.

In the following sections, we will explore how to implement parent and child classes, utilize special methods like __init__() and super(), and understand various types of inheritance in Python.

Parent Class In Python Inheritance

In Python, a parent class (also known as a base or superclass) is the class from which other classes, called child classes, inherit attributes and methods. 

• The parent class encapsulates common functionality that can be shared across multiple child classes, promoting code reuse and a logical class hierarchy. 
• Note that any class can be a parent class (even a class that inherits from another can be a parent class to some other.)

Example: Defining A Parent Class

In the simple Python program example below we have illustrated how to define a parent class named Person that includes attributes for first name and last name, along with a method to display the full name.

Code Example:

Output:

Shivani Goyal

Code Explanation:

In the simple Python code example:

• We define a class Person using the class keyword, with the class body indented after the class name.
• Inside the class, we define an __init__() method that initializes the first_name and last_name attributes when a new Person object is created.
• We also define a display_name() that uses the print() function with the f-string formatting to display the full name of the person by combining the first and last names.
• Then, we create an instance of the Person class, passing the values “Shivani” and “Goyal” for the two attributes.
• This invoked the constructor, i.e., the __init__() method that initializes the attributes.
• After that, we call the display_name() method on the person object, which prints the information to the console.

By defining common attributes and methods in the parent class, we establish a foundation that child classes can inherit and build upon, reducing redundancy and enhancing code maintainability.

Adding Attributes & Methods To Parent Class | Python Inheritance

A parent class can include various attributes and methods that encapsulate shared behaviors and properties. For instance, we can extend the Person class in the example above to include an age attribute and a method to display a greeting. The Python program example below contains the revised parent class definition and its usage.

Code Example:

Output:

Shivani Goyal
Hello, my name is Shivani Goyal and I am 30 years old.

Code Explanation:

In the Python code example:

• We define the Person class just like before, but time we have an additional attribute age in the __init__() constructor.
• We also define an additional method greet(), which takes an object of the class and uses the f-string to format the information before printing it to the console.
• Then, we create an object of the Person class, person and pass an additional value 30 for the age variable.
• As a result, when we call the greet() method on the person object, it uses values of all three attributes and prints it to the console.

By enriching the parent class with additional attributes and methods, we provide a robust base that child classes can inherit, ensuring consistency and reducing code duplication across related classes.

Child Class In Python Inheritance

In Python, a child class (also known as a derived or subclass) is a class that inherits attributes and methods from another class, referred to as the parent class. This Python inheritance allows the child class to utilize the existing functionality of the parent class and, if necessary, introduce its own unique attributes or methods.

Example: Defining A Child Class

Continuing with our previous example, let's define a child class named Employee that inherits from the Person parent class. In the basic Python program example below, we have the same Person class and have defined a child class with an additional attribute, employee_id, and the display() method.

Code Example:

Output:

Employee ID: U12345
Shivani Goyal
Age: 28

Code Explanation:

In the basic Python code example:

• We define a child class, Employee, that inherits from the Person class, allowing it to access the attributes and methods defined in Person.
• Inside this class, we define the __init__() method that overrides the constructor method from the Person class (we will discuss overriding in a later section).
• The method initializes the inherited attributes (first_name, last_name, age) using the super() function to call the constructor of the Person class and adds a new attribute, employee_id.
• We also define a function display_employee_details(), which displays the employee's ID, full name, and age. 
• Inside, we use the print() function to display the employee ID, then the display_name() method from the parent class.
• And then again, we display the age using the print() function, which by default includes a newline character and prints the information in the next line.
• Next, we can create an instance of the Employee class called employee passing the string values “Shivani”, “Goyal”, “U12345” for attributes first name, last name, ID, and value 30 for age.
• We use this employee object to call the display_empoyee_details() method which prints the information to the console.

In this example, the Employee class inherits common attributes and methods from the Person class, such as first_name, last_name, age, and display_name(). Additionally, it introduces a new attribute, employee_id, and a method, display_employee_details(), specific to the Employee class. 

This demonstrates how inheritance promotes code reuse and allows for the extension of existing functionality in a hierarchical class structure. In the following sections, we will explore the __init__() method and other components of a class and Python inheritance.

The __init__() Method In Python Inheritance

In Python, the __init__() method, known as the constructor, is automatically invoked when a new instance of a class is created. 

• It initializes the object's attributes, setting up the necessary state for the object. 
• When dealing with inheritance, it's crucial to ensure that the __init__() method of the parent class is properly invoked to initialize its attributes in the child class.
• A child class can override the __init__() method of its parent class to add its own attributes (like in the example above).

Let’s look at an example Python program that illustrates the use of __init__() methods and how the child class overrides it. We will continue with the previous examples, i.e., consider a parent class Person and a child class Employee that inherits from Person.

Code Example:

Code Explanation:

In the example Python code:

• The Person class's __init__() method initializes the first_name, last_name, and age attributes.
• The Employee class inherits from Person and introduces an additional attribute, employee_id.
• Within the Employee class's __init__() method, super().__init__(first_name, last_name, age) calls the parent class's constructor to initialize the inherited attributes.
• Just like in the previous example, we create an instance of the Employee class.
• We then use three print() functions to display the information as needed.

In this example, the Employee class's __init__() method ensures that the Person class's constructor is invoked, properly initializing the inherited attributes. This practice maintains the integrity of the object's state and leverages the initialization logic defined in the parent class.

Note: If the child class defines its own __init__() method without calling the parent class's __init__(), the inherited attributes may not be initialized correctly. Therefore, using super() to invoke the parent class's constructor is a recommended practice in Python inheritance. So, let’s take a closer look at the super() function.

The super() Function In Python Inheritance

In Python, the super() function provides a mechanism to access methods and properties of a parent class from within a child class. This is particularly useful in inheritance hierarchies, allowing child classes to extend or modify the behavior of parent classes without directly referencing them. Here is why we need to use the super() method to invoke the constructor (and other methods) of the parent class:

• Code Reusability: It enables child classes to reuse code from parent classes, promoting the DRY (Don't Repeat Yourself) principle.
• Avoiding Redundancy: Without super(), we would need to explicitly call the parent class's methods, leading to more verbose and less maintainable code.
• Maintainability: By avoiding hard-coded references to parent classes, super() facilitates easier maintenance and refactoring.
• Multiple Inheritance: In scenarios involving multiple inheritance, super() ensures that the correct method from the appropriate parent class is called, adhering to the method resolution order (MRO).

Example: Using super() in a Child Class

Let's consider a parent class Person and a child class Employee that inherits from Person. We'll use super() to call the parent class's __init__ method.

Code Example:

Code Explanation:

In the sample Python program:

• In the Employee class's __init__ method, super().__init__(first_name, last_name, age) calls the __init__ method of the Person class. This initializes the inherited attributes first_name, last_name, and age.
• By using super(), we avoid directly referencing the parent class, making the code more maintainable and adaptable to changes in the class hierarchy.

By utilizing super(), developers can write cleaner, more maintainable, and extensible code, effectively managing complex inheritance hierarchies in Python.

Method Overriding In Python Inheritance

In Python, method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. This allows the subclass to modify or extend the behavior of the inherited method to suit its specific needs.

• Same Method Signature: The overriding method in the subclass must have the same name and parameters as the method in the superclass.
• Inheritance Relationship: Method overriding is possible only when there is an inheritance relationship between classes.

Example: Method Overriding In Action (Python Inheritance)

Consider a superclass Person and a subclass Employee that overrides a method from the superclass:

Code Example:

Output:

Employee ID: U12345
Name: Shivani Goyal

Code Explanation:

In the sample Python code:

• The Employee class overrides the display_info method of the Person class to include the employee_id attribute.
• Within the overridden method, super().display_info() is called to invoke the display_info method of the superclass, ensuring that the full name is displayed.

By overriding methods, subclasses can tailor inherited behavior to meet specific requirements, enhancing the flexibility and functionality of object-oriented programming in Python.

Types Of Inheritance In Python

Python supports several types of inheritance, each serving different design purposes. In this section, we will discuss the 5 different types of inheritance with examples.

Single Inheritance In Python

Single inheritance enables a derived class to inherit properties and behaviors from a single-parent class. This is the most straightforward form of inheritance, facilitating a clear and simple class hierarchy.
Code Example:

Inheritance Hierarchy:

Person
  └── Employee

In this hierarchy, the Employee is the child class inheriting from the parent class Person. The Employee class gains access to the display_name method of the Person class, promoting code reuse and logical organization.

Multiple Inheritance In Python

Multiple inheritance allows a child class to inherit from more than one parent class. This enables the child class to combine functionalities of multiple base classes, providing a way to create complex behaviors by aggregating features from various sources.
Code Example:

Inheritance Hierarchy:

Flyer    Swimmer
     \       /
     Duck

Here, Duck inherits from both Flyer and Swimmer, combining the abilities to fly and swim. While multiple inheritance offers flexibility, it can introduce complexity, such as method resolution conflicts. Python addresses these issues using the Method Resolution Order (MRO), which determines the order in which base classes are searched when executing a method.

Multilevel Inheritance In Python

In multilevel inheritance, a class is derived from another class, which is also derived from another class, forming a top-to-bottom chain of inheritance. This type of inheritance models a hierarchical relationship where each level adds more specific functionality.
Code Example:

Inheritance Hierarchy:

LivingBeing
    └── Animal
          └── Dog

In this structure, Dog inherits from Animal, which in turn inherits from LivingBeing. This multilevel hierarchy allows each subclass to build upon the functionality of its superclass, creating a clear lineage of behaviors.

Hierarchical Inheritance In Python

Hierarchical inheritance occurs when multiple child classes inherit from the same parent class. This pattern is useful for defining common behaviors in a base class and then extending or modifying those behaviors in each subclass.
Code Example:

Inheritance Hierarchy:

      Vehicle
      /     \
 Car   Motorcycle

In this scenario, both Car and Motorcycle inherit from Vehicle, sharing the start_engine() method while implementing their own specific methods. This approach promotes code reuse and logical grouping of related classes.

Hybrid Inheritance In Python

Hybrid inheritance is a combination of multiple inheritance types, such as single, multiple, multilevel, and hierarchical inheritance. It allows for complex relationships by combining these inheritance patterns, enabling a more intricate and flexible class hierarchy. However, hybrid inheritance can introduce complexity and ambiguity, which Python manages using the Method Resolution Order (MRO).

Code Example:

Inheritance Hierarchy:

   LivingBeing
          /     \
   Animal  Bird
          \    /
          Bat

Code Explanation:

In this example, LivingBeing is the base class with a method live(). Both Animal and Bird classes inherit from LivingBeing, adding their specific methods, move() and fly(), respectively. The Bat class inherits from both Animal and Bird, combining the behaviors of moving and flying, and introduces its own method, hang_upside_down().

This structure demonstrates hybrid inheritance by combining multiple inheritance patterns:

• Hierarchical Inheritance: Both Animal and Bird classes inherit from the single base class LivingBeing.
• Multiple Inheritance: The Bat class inherits from both Animal and Bird classes.

By utilizing hybrid inheritance, the Bat class can access methods from all its parent classes, showcasing a complex yet organized class hierarchy. However, it's essential to manage such complexity carefully to avoid potential issues like the diamond problem, where ambiguity arises in the inheritance hierarchy. Python's MRO helps resolve such ambiguities by determining the order in which base classes are searched when executing a method.

Special Functions In Python Inheritance

In Python, special methods—often referred to as "magic methods" or "dunder methods" (short for "double underscore")—are predefined/built-in Python functions that enable classes to implement and customize behavior for built-in operations. 

• These methods allow objects to interact with Python's syntax and built-in functions in a natural and intuitive way.
• When dealing with inheritance, special methods are inherited just like regular methods. 
• This means that a subclass can override these methods to modify or extend their behavior. For instance, if a parent class defines the __init__ method, a subclass can override it to provide additional initialization steps. However, if the subclass does not override a special method, it inherits the implementation from the parent class.

Common Special Methods Used With Python Inheritance

• __init__(self): Constructor method, called when a new instance is created.
• __str__(self): Called by the string method str() and print() to return a string representation of the object.
• __repr__(self): Called by the repr() function and used in the interpreter to represent the object.
• __add__(self, other): Called when the + operator is used between two objects.
• __eq__(self, other): Called by the relational equality operator (==) to compare two objects for equality.

Code Example:

Code Explanation:

In this example, the Vehicle class defines the __init__ and __str__ special methods. 

• The Car subclass inherits from Vehicle and overrides the __str__ method to provide a more detailed string representation. 
• The super().__str__() call within the Car class allows it to include the string representation from the Vehicle class, enhancing the output without duplicating code.

By leveraging special methods in Python inheritance, you can create classes that integrate seamlessly with Python's syntax and built-in functions, leading to more readable and maintainable code.

Advantages & Disadvantages Of Inheritance In Python

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class to inherit attributes and methods from another class. In Python, inheritance promotes code reuse and establishes a hierarchical relationship between classes. However, like any programming construct, it comes with its own set of advantages and disadvantages.

Common Use Cases For Inheritance In Python

Inheritance in Python is commonly used to model hierarchical relationships, promote code reuse, and extend functionalities in various domains. Here are some common use cases:

1. Code Reusability: Python inheritance enables the creation of new classes that reuse code from existing classes, reducing redundancy and promoting efficient code management. For instance, a base class defining generic database operations can be inherited by specific derived classes for different types of databases.
2. Modularity and Organization: By establishing a hierarchy of classes, inheritance helps in organizing code into logical structures. This modular approach makes the codebase easier to understand and maintain.
3. Polymorphism: Inheritance facilitates polymorphism, allowing objects of different classes to be treated uniformly through a common interface. This flexibility enables writing more adaptable and generic code.
4. Extending Functionality: Derived classes can extend the functionality of base classes by adding new attributes and methods. This allows developers to build upon existing code and create specialized classes with additional features or behavior.
5. Frameworks and Libraries: Python inheritance is widely used in frameworks and libraries to provide customizable functionality. Developers can inherit from predefined classes in the framework or Python library and override or extend their methods to suit their specific needs.
6. GUI Frameworks: Python inheritance allows for the creation of a base class with common attributes and methods in graphical user interface (GUI) frameworks. This can be extended by subclasses representing specific GUI elements like buttons, text boxes, and labels. This approach promotes code reuse and a clear hierarchical structure.
7. Payment Processing Systems: Inheritance can be utilized in payment processing systems where a base class defines common payment methods, and subclasses implement specific processing logic for different payment types such as credit cards, PayPal, or bank transfers.
8. Game Development: In game development, Python inheritance allows for the creation of a base class representing general game entities, with subclasses defining specific behaviors for different types of characters, enemies, or non-playable characters (NPCs).
9. File I/O Systems: Inheritance can be applied in applications dealing with multiple file formats by creating a base class for file handling and extending it with subclasses that implement methods for reading and writing specific file types like text files, CSV files, or JSON files.

By leveraging inheritance, developers can create more organized, maintainable, and scalable codebases, leading to more efficient development processes and robust applications.

Best Practices for Implementing Inheritance in Python

Here are a few best practices to follow to ensure that you use Python inheritance effectively and maintainably:

1. Use Inheritance to Model "Is-A" Relationships: Inheritance should represent a clear "is-a" relationship between the parent and child classes. If a class does not logically fit as a subtype of another, inheritance may not be appropriate.
2. Avoid Deep Inheritance Hierarchies: Deep inheritance chains can become complex and difficult to manage. Aim for shallow hierarchies to maintain clarity and ease of maintenance.
3. Prefer Composition Over Inheritance When Appropriate: In some cases, composition (having objects contain instances of other classes) can be more appropriate than inheritance, especially when the relationship is better described as "has-a" rather than "is-a." This approach can lead to more flexible and decoupled designs.
4. Override Methods Carefully: When overriding methods in a subclass, ensure that the new implementation is compatible with the base class's interface and does not introduce unexpected behavior.
5. Utilize the super() Function Wisely: The super() function allows a subclass to call methods from its parent class. Use it judiciously to avoid unintended side effects, especially in complex inheritance hierarchies.
6. Be Aware of the Method Resolution Order (MRO): In multiple inheritance scenarios, Python determines the order in which base classes are considered using the MRO. Understanding MRO is crucial to avoid conflicts and ensure that the correct method is called.
7. Document Inheritance Hierarchies Clearly: Clearly document the relationships and responsibilities of classes in an inheritance hierarchy to aid in understanding and maintaining the codebase.

Avoiding Common Pitfalls in Python Inheritance

While inheritance offers many advantages, it's important to be aware of potential pitfalls:

• Tight Coupling: Inheritance can tightly couple subclasses to their parent classes, making changes in the parent class potentially disruptive to all subclasses. This can lead to maintenance challenges.
• The Diamond Problem: In multiple inheritance, if two parent classes have a method with the same name, and a subclass inherits from both, it can lead to ambiguity in which method is called. Understanding and managing the MRO is essential to resolve such conflicts.
• Overusing Inheritance: Not every relationship should be modeled with inheritance. Overusing inheritance can lead to complex and fragile code. Evaluate whether inheritance is the most appropriate design pattern for your scenario.

By adhering to these best practices and being mindful of common pitfalls, you can effectively leverage inheritance in Python to create clean, maintainable, and efficient code.

Conclusion

Python inheritance mechanism offers a robust framework for code reuse and the creation of hierarchical relationships between classes, promoting code reuse, and enhancing modularity.

• By understanding and applying inheritance appropriately, developers can build more efficient and maintainable object-oriented systems. 
• It's essential to balance the use of inheritance with other design principles, such as composition, to achieve optimal code structure and flexibility.
• By adhering to best practices—such as modeling clear "is-a" relationships, avoiding deep inheritance hierarchies, and considering composition over inheritance when appropriate—you can harness the full potential of inheritance while maintaining code clarity and flexibility. 
• Being mindful of common pitfalls, like tight coupling and the diamond problem, will further enhance the robustness and maintainability of your object-oriented designs.

Frequently Asked Questions

Q1. What is inheritance in Python?

Inheritance in Python allows a class (child class) to inherit attributes and methods from another class (parent class). This promotes code reuse and establishes a hierarchical relationship between classes.

Q2. How do I create a child class in Python?

To create a child class, define a new class and specify the parent class in parentheses:

class ChildClass(ParentClass):
    # class body

This syntax enables the child class to inherit all attributes and methods from the parent class.

Q3. What is the super() function, and how is it used?

The super() function returns a proxy object that represents the parent classes. It's commonly used to call methods from the parent class within a child class, facilitating method overriding and ensuring that the parent class's methods are properly invoked.

class ChildClass(ParentClass):
    def __init__(self):
        super().__init__()
        # additional initialization

Q4. Can a child class override methods from the parent class?

Yes, a child class can override methods from the parent class by defining a method with the same name. This allows the child class to provide a specific implementation of the method.

class ParentClass:
    def greet(self):
        print("Hello from Parent")
class ChildClass(ParentClass):
    def greet(self):
        print("Hello from Child")
obj = ChildClass()
obj.greet()  # Output: Hello from Child

Q5. What is multiple inheritance, and how does it work in Python?

Multiple inheritance allows a class to inherit from more than one parent class. In Python, this is achieved by specifying multiple parent classes in the class definition:

class ClassA:
    # class body
class ClassB:
    # class body
class ChildClass(ClassA, ClassB):
    # class body

Python uses the Method Resolution Order (MRO) to determine the order in which base classes are considered when searching for a method.

Q6. What is the Method Resolution Order (MRO) in Python?

The Method Resolution Order (MRO) is the order in which base classes are searched when executing a method. Python uses the C3 linearization algorithm to determine the MRO, ensuring a consistent and predictable method lookup. You can view the MRO of a class using the mro() method:

class ChildClass(ParentClass):
    pass
print(ChildClass.mro())

By now, you must know how to use Python inheritance to write efficient programs. Here are a few more articles you must explore:

1. Python IDLE | The Ultimate Beginner's Guide With Images & Codes
2. Python input() Function (+Input Casting & Handling With Examples)
3. If-Else Statement In Python | All Conditional Statements + Examples
4. Python Modules | Definition, Usage, Lists & More (+Code Examples)
5. Python Namespace & Variable Scope Explained (With Code Examples)
6. Python Assert Keyword | Types, Uses, Best Practices (+Code Examples)