Inheritance in Python: Types

Board Infinity -

Inheritance in Python is a model where one class acquires attributes and methods from another class. This concept is very useful in practicing the reusability of code and at the same time, deploys a linear form of the classes. Inheritance makes it easier and logical to have a well-structured code – especially in the way it is written.

This blog post gives the reader a chance to learn the behavior of different types of inheritance in Python and understand each type in detail.

Types of Inheritance In Python

Single Inheritance

Single inheritance is simple but serves as the basis for understanding other forms of inheritance which are discussed next. It enables a child class to adopt or inherit properties and methods from one parent class only.

Example:

#types of inheritance in python - Single Inheritance

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

    def speak(self):
        print(f"{self.name} makes a noise")


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def bark(self):
        print(f"{self.name}, the {self.breed}, barks")


# Creating an instance of Dog
dog = Dog("Buddy", "Golden Retriever")
dog.speak()  # Inherited method
dog.bark()   # Own method

Single inheritance is quite beneficial when you have a clean and uncomplicated line of succession. For example, a Dog class can extend and inherit from the Animal class. Code reusability is promoted, and repetition is distaste.

Multiple Inheritance

Multiple inheritances refer to a situation whereby one class is derived from more than one parent class. This comes in handy with the child class getting the functionality from the parent classes but also adds some complexity.

Example:

#types of inheritance in python - Multiple Inheritance

class Flyer:
    def fly(self):
        print("Flying high")


class Swimmer:
    def swim(self):
        print("Swimming in the water")


class Duck(Flyer, Swimmer):
    def quack(self):
        print("Quacking")


# Creating an instance of Duck
duck = Duck()
duck.fly()   # Inherited from Flyer
duck.swim()  # Inherited from Swimmer
duck.quack() # Own method

As multiple inheritances can let a class bring functionalities of depending classes, a critical problem might arise from this -  which is a conflict of attributes or methods.

Python solves such issues by use of Method Resolution Order, which is always used to define the sequence by which classes are checked for a particular method or attribute.

Multilevel Inheritance

Here, a class is inherited from a class which in turn is inherited from another class. This leads to an inheritance pattern that gives the way to making new, more complicated hierarchies.

Example:

#types of inheritance in python - Multilevel Inheritance

class Animal:
    def eat(self):
        print("Eating")


class Mammal(Animal):
    def walk(self):
        print("Walking")


class Dog(Mammal):
    def bark(self):
        print("Barking")


# Creating an instance of Dog
dog = Dog()
dog.eat()   # Inherited from Animal
dog.walk()  # Inherited from Mammal
dog.bark()  # Own method

It means that multilevel inheritance will be helpful when using classes for creating complex relationships. But, it also comes with a number of problems concerning maintainability. That means that changes in higher levels of the hierarchy can in any way affect derived classes.

Hierarchical Inheritance

In this concept one parent class is used to create multiple classes and all the classes have the same parent. Such inheritance is most useful when creating classes that should contain common sets of methods and properties.

Example: 

#types of inheritance in python - Hierarchical Inheritance

class Animal:
    def speak(self):
        print("Animal speaks")


class Dog(Animal):
    def bark(self):
        print("Dog barks")


class Cat(Animal):
    def meow(self):
        print("Cat meows")


# Creating instances of Dog and Cat
dog = Dog()
cat = Cat()

dog.speak()  # Inherited from Animal
dog.bark()   # Own method

cat.speak()  # Inherited from Animal
cat.meow()   # Own method

It is used in a way that would allow testing of general behaviors or characteristics of a parent class and then have those behaviors checked in several child classes. It makes for a more consistent and friendly surface and complements code reuse.

Hybrid Inheritance

Hybrid inheritance is also known as multiple type inheritance whereby an object can have two or more types of inheritance. It is used commonly in high-level designs and is more flexible than the first one.

Example:

#types of inheritance in python - Hybrid Inheritance

class Vehicle:
    def move(self):
        print("Vehicle is moving")


class Car(Vehicle):
    def drive(self):
        print("Car is driving")


class Boat(Vehicle):
    def sail(self):
        print("Boat is sailing")


class AmphibiousVehicle(Car, Boat):
    pass


# Creating an instance of AmphibiousVehicle
amphibious_vehicle = AmphibiousVehicle()
amphibious_vehicle.move()  # Inherited from Vehicle
amphibious_vehicle.drive() # Inherited from Car
amphibious_vehicle.sail()  # Inherited from Boat

Hybrid inheritance can sometimes be a little complicated since there will be multiple inheritance channels. Python’s Method resolution order (MRO) system guarantees the usage of the correct method or attribute when the path linkage is multiple. It should however be used sparingly when developing a system since it offers flexibility in the way a complicated system is developed.

Benefits of Inheritance

  1. Code Reusability: Since methods and attributes can be inherited, there is minimal duplication or rewrite of codes.
  2. Maintainability: When a base class is modified it is possible to make a change in the behavior of all derived classes, meaning that the classes are easy to maintain.
  3. Extensibility: Additions to new functionality may be introduced to the derived classes without the participation of the base class.
  4. Polymorphism: This makes it possible for derived classes to be treated as the base class for the purpose of dynamic method bindery.

Drawbacks of Inheritance

  1. Increased Coupling: Classes become coupled which are specific and when altered affect other classes.
  2. Complexity: In Python inheritance types like multiple and hybrid inheritance have confusing code structure and class usage.
  3. Overhead: Base class, including unnecessary methods and attributes, may be inherited, thus raising the consumption of memory.

Best Practices

  1. Prefer Composition Over Inheritance: Inheritance should only be used when there exists a strictly defined relationship where one class is above any other.
  2. Use Interfaces or Abstract Classes: Lay down clear expectations for these derived classes in terms of what they’re expected to deliver.
  3. Keep Hierarchies Shallow: Failure should be capable of handling complex issues, but failure should also be avoided until deeper inheritance chains are created.
  4. Avoid Multiple Inheritance When Possible: To avoid confusion and for the purpose of convenience.

Conclusion

Knowing the distinctions between types of inheritance in Python and its uses really adds a plus point to the flow of code layout. Inheritance is a potent incantation, but like all incantations, should be applied sparingly with an eye to its blessings as well as its curses.

Therefore, if you are to write good code that is easily scalable and maintainable, you should follow the code standards set for Python and also utilize MRO from Python to develop a reliable code base.