46. Python Essentials: Inheritance in Python: Extending Classes and Building Hierarchies

Screenshot from the tutorial

Understanding Inheritance in Python: Extending Classes and Building Hierarchies

Inheritance is one of the core concepts of object-oriented programming (OOP), and Python makes it easy to work with inheritance to create more sophisticated and reusable code. In this blog post, we'll delve into the essentials of inheritance in Python, exploring how to extend classes and build class hierarchies effectively.

What is Inheritance?

Inheritance allows a class (known as a child or subclass) to inherit attributes and methods from another class (known as a parent or superclass). This mechanism promotes code reuse and establishes a natural hierarchy between classes.

Benefits of Inheritance

1. Code Reusability: You can create new classes based on existing ones, minimizing redundancy.
2. Logical Structure: It helps create a clear structure and hierarchy, making the codebase easier to understand.
3. Polymorphism: It allows methods to be used interchangeably, enhancing flexibility.

Basic Syntax of Inheritance

In Python, inheritance is defined by passing the parent class as an argument to the child class. The general syntax is:

class ParentClass:
    # Parent class attributes and methods
    pass

class ChildClass(ParentClass):
    # Child class attributes and methods
    pass

Example of Basic Inheritance

Let’s consider a simple example where we create a Vehicle class and a Car class that inherits from it.

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

    def display_info(self):
        return f'Vehicle Make: {self.make}, Model: {self.model}'

class Car(Vehicle):
    def __init__(self, make, model, doors):
        super().__init__(make, model)  # Call the constructor of the parent class
        self.doors = doors

    def display_info(self):
        parent_info = super().display_info()  # Call the parent class's method
        return f'{parent_info}, Doors: {self.doors}'

# Usage
my_car = Car('Toyota', 'Corolla', 4)
print(my_car.display_info())

Output

Vehicle Make: Toyota, Model: Corolla, Doors: 4

In this example, the Car class inherits the properties (attributes and methods) of the Vehicle class. The super() function allows us to call the parent class's methods and attributes.

Extending Classes

When you extend a class, you can override its methods to provide new functionality. This is particularly useful when you want to modify or enhance the behavior of inherited methods.

Overriding Methods

You can override a method in a subclass by defining a method with the same name in the child class. Here’s how you can do it:

class Truck(Vehicle):
    def display_info(self):
        return f'This is a truck from {self.make} with model {self.model}.'

# Usage
my_truck = Truck('Ford', 'F-150')
print(my_truck.display_info())

Output

This is a truck from Ford with model F-150.

In the Truck class, we override the display_info method to provide a more specific message.

Building Class Hierarchies

Inheritance can be extended to create complex hierarchies. You can have multiple levels of inheritance, where subclasses can also act as parent classes.

Example of Class Hierarchy

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

    def display_info(self):
        return f'{super().display_info()}, Type: {self.type_of_motorcycle}'

class SportBike(Motorcycle):
    def display_info(self):
        return f'SportBike - {super().display_info()}'

# Usage
my_bike = SportBike('Ducati', 'Panigale', 'Sport')
print(my_bike.display_info())

Output

SportBike - Vehicle Make: Ducati, Model: Panigale, Type: Sport

In this example, SportBike is a subclass of Motorcycle, which in turn is a subclass of Vehicle. This shows how you can build a hierarchy of classes that inherit from one another.

Conclusion

Inheritance is a powerful feature in Python that promotes code reuse and helps in organizing your code into logical hierarchies. By understanding how to extend classes and build class hierarchies, you can create more maintainable and scalable applications.

Whether you're working on a small project or a large application, mastering inheritance will significantly enhance your Python programming skills. Happy coding!

Another view from the tutorial

---

Connect with SkillBakery Studios

Explore more tutorials, tools, and resources:

• skillbakery.com
• Facebook
• X (Twitter)
• YouTube Channel

Posted by SkillBakery Studios