Post

Understanding Inheritance in Python: A Core Pillar of OOP

Posted
By Shivraj Badu 7 min read

Understanding Inheritance in Python: A Core Pillar of OOP

Introduction

Object-Oriented Programming (OOP) provides a powerful paradigm for structuring software. It revolves around the concepts of objects and classes, which bundle data and functionality together. Among the four major pillars of OOP—Encapsulation, Abstraction, Polymorphism, and Inheritance—it is inheritance that provides a mechanism for creating logical, hierarchical relationships between classes, promoting code reuse and organization.

Think of biological classification. A Golden Retriever is a type of Dog, and a Dog is a type of Animal. The Golden Retriever “inherits” traits common to all dogs (like barking), and all dogs inherit traits common to all animals (like breathing). In programming, inheritance allows a new class, known as a child or subclass, to be based on an existing class, the parent or superclass. The child class automatically acquires all the attributes and methods of its parent, which it can then use, extend, or override.

This article provides a comprehensive guide to understanding and using inheritance in Python, from basic syntax to more advanced concepts like multiple inheritance and the Method Resolution Order (MRO).

Basic Inheritance: The “Is-A” Relationship

At its core, inheritance models an “is-a” relationship. A Car is a Vehicle. A Button is a UIElement. Let’s start with a simple example. We’ll define a parent class Animal and a child class Dog.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Parent class (Superclass)
class Animal:
    def __init__(self, name):
        self.name = name
        print(f"Animal '{self.name}' created.")

    def speak(self):
        return "Some generic animal sound"

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

# Child class (Subclass)
class Dog(Animal):  # The Dog class inherits from the Animal class
    pass  # For now, we add no extra functionality

# Let's create instances
generic_animal = Animal("Creature")
print(generic_animal.speak())
print(generic_animal.eat())

print("-" * 20)

my_dog = Dog("Buddy")  # Notice the __init__ message from Animal is printed
print(my_dog.name)     # Accessing attribute from the parent
print(my_dog.speak())  # Calling method from the parent
print(my_dog.eat())    # Calling another method from the parent

Output:

1
2
3
4
5
6
7
8

Animal 'Creature' created.
Some generic animal sound
Creature is eating.
--------------------
Animal 'Buddy' created.
Buddy
Some generic animal sound
Buddy is eating.

As you can see, even though the Dog class is empty (pass), it automatically has a name attribute and the speak() and eat() methods because it inherited them from Animal. When we created the Dog instance, Python automatically called the __init__ method from the Animal class.

Method Overriding: Specializing Behavior

The generic speak() method in Animal isn’t very descriptive for a dog. A key feature of inheritance is the ability for a child class to provide its own specific implementation of a parent’s method. This is called method overriding.

Let’s give our Dog class its own speak() method.

1
2
3
4
5
6
7

class Dog(Animal):
    def speak(self):  # Overriding the parent's speak method
        return "Woof! Woof!"

my_dog = Dog("Rex")
print(my_dog.speak())  # This now calls the Dog's version of speak()
print(my_dog.eat())    # This still calls the Animal's version of eat()

Output:

1
2
3

Animal 'Rex' created.
Woof! Woof!
Rex is eating.

Now, when my_dog.speak() is called, Python finds the speak method in the Dog class first and executes it. The eat() method, which is not defined in Dog, is found in the parent Animal class and executed from there.

Extending Parent Methods with super()

What if we want to add to the parent’s method, not completely replace it? For instance, maybe we want our Dog’s __init__ to accept a breed in addition to a name. We still need to run the parent’s __init__ to set the name.

This is where the super() function comes in. It provides a way to call methods from the parent class.

1
2
3
4
5
6
7
8
9
10
11
12

class Dog(Animal):
    def __init__(self, name, breed):
        # Call the parent's __init__ method to handle the 'name'
        super().__init__(name)
        self.breed = breed
        print(f"Dog of breed '{self.breed}' created.")

    def speak(self):
        return "Woof! Woof!"

my_poodle = Dog("Fifi", "Poodle")
print(f"Name: {my_poodle.name}, Breed: {my_poodle.breed}")

Output:

1
2
3

Animal 'Fifi' created.
Dog of breed 'Poodle' created.
Name: Fifi, Breed: Poodle

Here, super().__init__(name) explicitly calls the __init__ method of the Animal class, which sets self.name. The Dog class’s __init__ then proceeds to set the self.breed attribute. Using super() is the standard and recommended way to extend parent methods, as it makes the code more maintainable and works correctly with more complex inheritance structures.

Types of Inheritance

Python is very flexible and supports several kinds of inheritance.

1. Multiple Inheritance

A class can inherit from more than one parent class. This allows it to combine functionalities from different sources.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Flyer:
    def fly(self):
        return "Flying high!"

class Swimmer:
    def swim(self):
        return "Swimming smoothly!"

# Duck inherits from Animal, Flyer, and Swimmer
class Duck(Animal, Flyer, Swimmer):
    def speak(self):
        return "Quack!"

my_duck = Duck("Donald")
print(my_duck.speak())
print(my_duck.fly())
print(my_duck.swim())
print(my_duck.eat())

Output:

1
2
3
4
5

Animal 'Donald' created.
Quack!
Flying high!
Swimming smoothly!
Donald is eating.

Our Duck class now has behaviors from all three of its parents.

Method Resolution Order (MRO)

With multiple inheritance, a potential problem arises: if multiple parent classes have a method with the same name, which one gets called? This is known as the “diamond problem” in more complex hierarchies.

Python solves this with the Method Resolution Order (MRO), a deterministic algorithm (C3 linearization) that defines the order in which base classes are searched. You can inspect the MRO of any class using the mro() method or the __mro__ attribute.

1
2

print(Duck.mro())
# Or: print(Duck.__mro__)

Output:

1

[<class '__main__.Duck'>, <class '__main__.Animal'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>]

This list shows the lookup order: Duck -> Animal -> Flyer -> Swimmer -> object (the base class for all classes in Python).

2. Multilevel Inheritance

This is when you have a chain of inheritance: A -> B -> C.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

class Dog(Animal):  # Inherits from Animal
    def speak(self):
        return "Woof!"

class Poodle(Dog):  # Inherits from Dog
    def dance(self):
        return "Dancing a poodle dance!"

my_poodle = Poodle("Mimi")
print(my_poodle.name)      # From Animal
print(my_poodle.speak())   # From Dog
print(my_poodle.dance())   # From Poodle

The Poodle class inherits from Dog, which in turn inherits from Animal. Therefore, Poodle has access to methods and attributes from both Dog and Animal.

Checking Relationships: isinstance() and issubclass()

Python provides two helpful built-in functions to check inheritance relationships:

  • isinstance(obj, Class): Returns True if the object obj is an instance of Class or any of its subclasses.
  • issubclass(Child, Parent): Returns True if Child is a subclass of Parent.
1
2
3
4
5
6
7
8
9
10
11

my_poodle = Poodle("Charlie")

print(f"Is my_poodle an instance of Poodle? {isinstance(my_poodle, Poodle)}")   # True
print(f"Is my_poodle an instance of Dog? {isinstance(my_poodle, Dog)}")       # True
print(f"Is my_poodle an instance of Animal? {isinstance(my_poodle, Animal)}") # True

print("-" * 20)

print(f"Is Poodle a subclass of Dog? {issubclass(Poodle, Dog)}")         # True
print(f"Is Poodle a subclass of Animal? {issubclass(Poodle, Animal)}")   # True
print(f"Is Dog a subclass of Poodle? {issubclass(Dog, Poodle)}")         # False

Conclusion

Inheritance is a fundamental concept in Python’s object-oriented programming model. It enables developers to create clean, logical, and reusable code by building hierarchical class structures. By allowing child classes to inherit, extend, and override the functionality of parent classes, inheritance reduces redundancy and makes software easier to manage and scale.

Whether you are using simple single inheritance to model a specific type of object or leveraging multiple inheritance to mix in different functionalities, a solid grasp of this pillar of OOP is essential for writing effective and elegant Python applications.

Suggested Reading

Python, Programming
python oop inheritance classes
This post is licensed under CC BY 4.0 by the author.