Inheritance in Python





Inheritance is a powerful feature of object-oriented programming that allows classes to inherit attributes and methods from other classes. It promotes code reuse, modularity, and extensibility, enabling the creation of hierarchies of related classes. In Python, inheritance is implemented through class inheritance, where a derived class inherits the properties and behaviors of a base class. In this article, we will delve into the concept of inheritance in Python, explore its syntax, understand the benefits it offers, and learn how to leverage it effectively to create reusable and structured code.



Understanding Inheritance :

Inheritance is a relationship between classes, where one class (derived class or subclass) derives properties and behaviors from another class (base class or superclass). The derived class inherits all the attributes and methods of the base class and can also add its unique attributes and methods.



Syntax of Inheritance :

To create a subclass that inherits from a base class, use the following syntax: 

                
                  
                    class BaseClass:
                      # Base class definition

                    class DerivedClass(BaseClass):
                      # Derived class definition

In this syntax, 'BaseClass' is the name of the base class, and 'DerivedClass' is the name of the derived class.



Accessing Base Class Methods and Attributes :

In the derived class, you can access the methods and attributes of the base class using the 'super()' function. The 'super()' function returns a temporary object of the superclass, allowing you to call its methods or access its attributes.

Example: 

              
                
                  class Animal:
                    def __init__(self, name):
                        self.name = name
                    
                    def sound(self):
                        print("Animal sound")

                  class Dog(Animal):
                    def __init__(self, name, breed):
                        super().__init__(name)
                        self.breed = breed
                    
                    def sound(self):
                        super().sound()
                        print("Bark")

                  # Creating an instance of the Dog class
                  dog = Dog("Buddy", "Labrador")
                  dog.sound()  # Output: Animal sound Bark

In this example, the 'Dog' class inherits from the 'Animal' class. The 'super().__init__(name)' line in the 'Dog' class constructor calls the constructor of the 'Animal' class, allowing the 'name' attribute to be initialized. The 'super().sound()' line in the 'sound()' method calls the 'sound()' method of the 'Animal' class, and the derived class adds its unique behavior.



Method Overriding :

Inheritance allows us to override methods from the base class in the derived class. Method overriding allows the derived class to provide its own implementation for a method defined in the base class, thereby customizing the behavior.

Here's an example: 

              
                
                  class Vehicle:
                    def drive(self):
                        print("Driving a vehicle")

                  class Car(Vehicle):
                    def drive(self):
                        print("Driving a car")

                  # Creating an instance of the Car class
                  car = Car()
                  car.drive()  # Output: Driving a car

In this example, the 'Car' class overrides the 'drive()' method inherited from the 'Vehicle' class and provides its own implementation.



Abstract Base Classes (ABC) :

Python provides the 'abc' module to define abstract base classes. An abstract base class defines a common interface for its subclasses but cannot be instantiated itself. Subclasses must implement the methods defined in the abstract base class.

Here's an example for better understanding: 

              
                
                  from abc import ABC, abstractmethod

                  class Shape(ABC):
                    @abstractmethod
                    def area(self):
                        pass

                  class Rectangle(Shape):
                    def __init__(self, width, height):
                        self.width = width
                        self.height = height
                    
                    def area(self):
                        return self.width * self.height

                  # Creating an instance of the Rectangle class
                  rectangle = Rectangle(5, 3)
                  print(rectangle.area())  # Output: 15

In this example, the 'Shape' class is an abstract base class with an abstract method 'area()'. The Rectangle class inherits from 'Shape' and provides its implementation for the 'area()' method.