Python Class Inheritance Tutorial (With Examples)

In object-oriented programming (OOP), class inheritance is a fundamental concept that allows you to create new classes based on existing ones. It facilitates code reuse and promotes the creation of more organized and maintainable code. In this tutorial, we’ll delve into the concept of class inheritance in Python, discussing its benefits, how to define and use inherited classes, and providing practical examples to solidify your understanding.

Table of Contents

1. Introduction to Class Inheritance
   • What is Class Inheritance?
   • Benefits of Class Inheritance
2. Defining Inherited Classes
   • Syntax for Inheritance
   • Overriding Methods
3. Example 1: Building a Basic Inheritance Hierarchy
4. Example 2: Creating a Real-world Scenario
5. Multiple Inheritance
   • Diamond Inheritance Problem
6. Method Resolution Order (MRO)
7. Conclusion

1. Introduction to Class Inheritance

What is Class Inheritance?

Class inheritance is a fundamental concept in object-oriented programming that enables a new class (called a subclass or derived class) to inherit attributes and behaviors (methods) from an existing class (called a superclass or base class). This allows you to create specialized classes that build upon the functionality of their parent classes. Inheritance promotes code reuse and helps create a hierarchy of related classes.

Benefits of Class Inheritance

• Code Reusability: Inheritance allows you to avoid duplicating code. Common attributes and methods can be defined in a base class, and subclasses can inherit and extend this functionality.
• Organization: Inheritance promotes the creation of organized and structured code. Related classes can be grouped under a common superclass, leading to a more manageable codebase.
• Modularity: You can modify or extend the behavior of a base class by creating a subclass. This modularity makes your code easier to maintain and update.
• Polymorphism: Inheritance is closely related to the concept of polymorphism. Subclasses can override or extend methods from their parent classes, allowing for different implementations of the same method.

2. Defining Inherited Classes

Syntax for Inheritance

In Python, class inheritance is implemented using the following syntax:

class BaseClass:
    # Attributes and methods of the base class

class SubClass(BaseClass):
    # Additional attributes and methods specific to the subclass

The SubClass here is inheriting from BaseClass, which means that SubClass will have access to all attributes and methods defined in BaseClass.

Overriding Methods

Subclasses can override methods inherited from their parent classes. This means that you can provide a different implementation for a method in the subclass. This is particularly useful when you want to customize behavior while maintaining a common interface.

class BaseClass:
    def greet(self):
        print("Hello from BaseClass!")

class SubClass(BaseClass):
    def greet(self):
        print("Hello from SubClass!")

In this example, the greet method in SubClass overrides the method in BaseClass. When you create an instance of SubClass and call the greet method, the overridden implementation in SubClass will be executed.

3. Example 1: Building a Basic Inheritance Hierarchy

Let’s start with a simple example to demonstrate class inheritance. We’ll create a hierarchy of classes representing different types of vehicles.

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def display_info(self):
        print(f"Make: {self.make}, Model: {self.model}")

class Car(Vehicle):
    def __init__(self, make, model, num_doors):
        super().__init__(make, model)
        self.num_doors = num_doors

    def display_info(self):
        super().display_info()
        print(f"Number of doors: {self.num_doors}")

class Motorcycle(Vehicle):
    def __init__(self, make, model, engine_size):
        super().__init__(make, model)
        self.engine_size = engine_size

    def display_info(self):
        super().display_info()
        print(f"Engine size: {self.engine_size}")

In this example, we have a base class Vehicle with attributes make and model, along with a method display_info to display these attributes. We then have two subclasses, Car and Motorcycle, each with additional attributes and overridden display_info methods.

Let’s create instances of these classes and see how inheritance works:

car = Car("Toyota", "Camry", 4)
motorcycle = Motorcycle("Harley-Davidson", "Sportster", "1200cc")

car.display_info()
motorcycle.display_info()

Output:

Make: Toyota, Model: Camry
Number of doors: 4

Make: Harley-Davidson, Model: Sportster
Engine size: 1200cc

4. Example 2: Creating a Real-world Scenario

Let’s explore a more practical example involving a simple e-commerce system. We’ll define a base class Product and two subclasses, Electronics and Clothing, each with their specific attributes.

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def display_info(self):
        print(f"Product: {self.name}, Price: ${self.price:.2f}")

class Electronics(Product):
    def __init__(self, name, price, brand):
        super().__init__(name, price)
        self.brand = brand

    def display_info(self):
        super().display_info()
        print(f"Brand: {self.brand}")

class Clothing(Product):
    def __init__(self, name, price, size):
        super().__init__(name, price)
        self.size = size

    def display_info(self):
        super().display_info()
        print(f"Size: {self.size}")

In this example, the base class Product has attributes name and price, along with a display_info method. The subclasses Electronics and Clothing have additional attributes and overridden display_info methods.

Let’s create instances of these classes and observe inheritance in action:

phone = Electronics("Smartphone", 799.99, "Samsung")
shirt = Clothing("T-shirt", 19.99, "M")

phone.display_info()
shirt.display_info()

Output:

Product: Smartphone, Price: $799.99
Brand: Samsung

Product: T-shirt, Price: $19.99
Size: M

5. Multiple Inheritance

Python supports multiple inheritance, allowing a class to inherit from more than one base class. This can be powerful, but it also introduces complexities. Consider the following example:

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

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

class C(A, B):
    pass

obj = C()
obj.show()

Output:

A

Here,

class C inherits from both classes A and B. When the show method is called on an instance of C, Python resolves the method based on the Method Resolution Order (MRO), which is the order in which base classes are searched for a method.

6. Method Resolution Order (MRO)

In Python, the MRO determines the sequence in which base classes are considered when looking up a method or attribute in a subclass. The built-in function super() uses the MRO to ensure that methods are called in the correct order.

To understand the MRO, you can use the mro() method or the __mro__ attribute:

print(C.mro())
print(C.__mro__)

Output:

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

In this example, the MRO for class C is [C, A, B, object], meaning that when searching for methods or attributes in class C, it will first check class A, then class B, and finally the base class object.

7. Conclusion

Class inheritance is a powerful concept in Python’s object-oriented programming paradigm. It enables code reuse, promotes organization, and allows for the creation of hierarchies of related classes. By understanding how to define inherited classes, override methods, and manage multiple inheritance scenarios, you can leverage the benefits of inheritance to create efficient and maintainable code. Remember to consider the Method Resolution Order (MRO) when dealing with complex class hierarchies. With the knowledge gained from this tutorial, you’re well-equipped to utilize class inheritance effectively in your Python projects.