Python Inheritance

Inheritance is a fundamental concept in object-oriented programming (OOP) that enables you to create new classes from existing ones. In Python, you can use inheritance to define a class that inherits attributes and methods from a parent class. In this blog post, we will explore inheritance in Python, its types, and examples.

Types of Inheritance

Python supports multiple types of inheritance, including single inheritance, multiple inheritance, and multi-level inheritance.

Single Inheritance

Single inheritance is a feature of object-oriented programming that allows a class to inherit properties and methods from a single parent class. In Python, we can implement single inheritance by creating a subclass that inherits from a single parent class.

Here's an example:

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def eat(self):
        print(f"{self.name} is eating")

class Dog(Animal):
    def bark(self):
        print("Woof!")

my_dog = Dog("Fido", "Canine")
print(my_dog.name)
my_dog.eat()
my_dog.bark()

In this example, we have a parent class called Animal that has an __init__ method to initialize the name and species of an animal, as well as an eat method that prints a message to indicate that the animal is eating.

We also have a child class called Dog that inherits from the Animal class using the syntax class Dog(Animal):. The Dog class has a method called bark that prints "Woof!".

We then create an instance of the Dog class called my_dog, passing in "Fido" as the name and "Canine" as the species. We can then access the name property of my_dog using my_dog.name. We can also call the eat method using my_dog.eat(), which will print the message "Fido is eating". Finally, we can call the bark method using my_dog.bark(), which will print the message "Woof!".

In this example, Dog class is the child class that inherits from the Animal class, which is the parent class. The child class Dog has access to all the properties and methods of the parent class Animal. This is the essence of single inheritance.

Multiple Inheritance

Multiple inheritance is a feature of object-oriented programming that allows a class to inherit properties and methods from multiple parent classes. In Python, we can implement multiple inheritance by creating a subclass that inherits from multiple parent classes using the syntax class Subclass(ParentClass1, ParentClass2, ...):.

Here's an example:

  class Flyer:
    def fly(self):
        print("I'm flying!")

class Swimmer:
    def swim(self):
        print("I'm swimming!")

class FlyingFish(Flyer, Swimmer):
    pass

my_flying_fish = FlyingFish()
my_flying_fish.fly()
my_flying_fish.swim()

In this example, we have two parent classes called Flyer and Swimmer that have methods fly and swim, respectively.

We also have a child class called FlyingFish that inherits from both Flyer and Swimmer using the syntax class FlyingFish(Flyer, Swimmer):. The FlyingFish class doesn't have any methods of its own, but it inherits the fly method from the Flyer class and the swim method from the Swimmer class.

We then create an instance of the FlyingFish class called my_flying_fish. We can call the fly method using my_flying_fish.fly(), which will print the message "I'm flying!". We can also call the swim method using my_flying_fish.swim(), which will print the message "I'm swimming!".

In this example, FlyingFish class is the child class that inherits from both Flyer and Swimmer classes. This is the essence of multiple inheritance.

Multi-level Inheritance

Multi-level inheritance is a feature of object-oriented programming that allows a class to inherit from a parent class, which itself inherits from another parent class. In Python, we can implement multi-level inheritance by creating a subclass that inherits from a parent class, which itself inherits from another parent class.

Here's an example:

  class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def eat(self):
        print(f"{self.name} is eating")

class Pet(Animal):
    def __init__(self, name, species, owner):
        super().__init__(name, species)
        self.owner = owner

    def play(self):
        print(f"{self.name} is playing with {self.owner}")

class Dog(Pet):
    def bark(self):
        print("Woof!")

my_dog = Dog("Fido", "Canine", "John")
print(my_dog.name)
my_dog.eat()
my_dog.play()
my_dog.bark()
  

In this example, we have a parent class called Animal that has an __init__ method to initialize the name and species of an animal, as well as an eat method that prints a message to indicate that the animal is eating.

We also have a child class called Pet that inherits from the Animal class. The Pet class has an __init__ method that takes an additional owner parameter, and calls the __init__ method of the Animal class using the super() function. The Pet class also has a play method that prints a message to indicate that the pet is playing with its owner.

Finally, we have a child class called Dog that inherits from the Pet class. The Dog class has a bark method that prints "Woof!".

We then create an instance of the Dog class called my_dog, passing in "Fido" as the name, "Canine" as the species, and "John" as the owner. We can then access the name property of my_dog using my_dog.name. We can also call the eat method using my_dog.eat(), which will print the message "Fido is eating". We can call the play method using my_dog.play(), which will print the message "Fido is playing with John". Finally, we can call the bark method using my_dog.bark(), which will print the message "Woof!".

In this example, Pet class is the child class that inherits from the Animal class, which is the parent class. The Dog class is the child class that inherits from the Pet class, which is itself a child class of the Animal class. This is the essence of multi-level inheritance.

Please subscribe to my youtube channel for latest python tutorials and this article