Inheritance

Introduction

Suppose you are modeling different kinds of employees: Manager, Developer, and Intern. All of them share common attributes like name and salary, but each also has behavior that is uniquely its own. Rewriting the shared parts in every class would be repetitive and error-prone. Inheritance solves exactly this kind of problem.

In this lesson, you will learn how to create a child class that reuses a parent class's code, how to override methods to specialize behavior, how super() lets a child call back into its parent, and a high-level look at multiple inheritance.

What is Inheritance?

Inheritance lets one class (the child, or subclass) automatically acquire the attributes and methods of another class (the parent, or superclass), without rewriting that code. The child class can then add new behavior of its own or override inherited behavior.

Inheritance is used to model "is-a" relationships: a Manager is an Employee, a Dog is an Animal, a Circle is a Shape. If the relationship between two things cannot honestly be described with "is-a," inheritance is probably the wrong tool.

Creating a Child Class

To make one class inherit from another, put the parent class name inside parentheses after the child class name: class Child(Parent):. The child automatically gains every attribute and method the parent defines.

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

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


class Dog(Animal):   # Dog inherits from Animal
    pass


d = Dog("Rex")
d.speak()   # inherited directly from Animal

Rex makes a sound.

Dog did not define __init__ or speak() itself — it simply inherited both from Animal. Even an empty child class (using pass) gets everything the parent defines.

Method Overriding

A child class can redefine a method it inherited, replacing the parent's version with its own. This is called method overriding — the method name stays the same, but the behavior changes for that subclass.

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

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


class Dog(Animal):
    def speak(self):   # overrides Animal.speak()
        print(f"{self.name} barks.")


class Cat(Animal):
    def speak(self):   # overrides Animal.speak()
        print(f"{self.name} meows.")


Animal("Generic Animal").speak()
Dog("Rex").speak()
Cat("Whiskers").speak()

Generic Animal makes a sound.
Rex barks.
Whiskers meows.

Calling the Parent with super()

Sometimes you want to override a method but still run the parent's original version as part of the new behavior, instead of replacing it entirely. The super() function gives you a reference to the parent class so you can call its methods from within the child.

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

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


class Dog(Animal):
    def speak(self):
        super().speak()          # run the parent's version first
        print(f"{self.name} also barks loudly.")


Dog("Rex").speak()

Rex makes a sound.
Rex also barks loudly.

Extending __init__ in a Subclass

A very common pattern is a subclass that needs extra attributes beyond what the parent stores. Rather than duplicating the parent's __init__, the child calls super().__init__() to handle the shared setup, then adds its own attributes.

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary


class Manager(Employee):
    def __init__(self, name, salary, team_size):
        super().__init__(name, salary)   # reuse the parent's setup
        self.team_size = team_size       # add Manager-specific data

    def summary(self):
        print(f"{self.name} manages a team of {self.team_size}, earning {self.salary}.")


m = Manager("Aditi", 90000, 6)
m.summary()

Aditi manages a team of 6, earning 90000.

Multiple Inheritance (Brief Overview)

Python allows a class to inherit from more than one parent class at the same time, unlike languages such as Java. This is called multiple inheritance.

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


class Swimmer:
    def swim(self):
        print("Swimming!")


class Duck(Flyer, Swimmer):   # inherits from BOTH parents
    pass


d = Duck()
d.fly()
d.swim()

Flying!
Swimming!

Duck gains behavior from both Flyer and Swimmer. This is powerful, but it can get complicated quickly if multiple parents define methods with the same name — which is where method resolution order comes in.

Method Resolution Order (MRO) — High Level

When a class inherits from multiple parents (or forms a longer chain of inheritance), Python needs a consistent rule to decide which method to use if more than one ancestor defines a method with the same name. This rule is called the Method Resolution Order, and Python computes it automatically using an algorithm called C3 linearization.

class Duck(Flyer, Swimmer):
    pass

print(Duck.__mro__)

(<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

Why Inheritance Matters

Inheritance is one of the main tools for reducing duplicate code and organizing related classes into a logical hierarchy.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Inheritance allows classes to build on top of one another, reusing shared code through a parent-child relationship and specializing behavior through method overriding and super(). It models real "is-a" relationships and, when combined with multiple inheritance, follows a predictable Method Resolution Order.

Next, you will build directly on method overriding to understand polymorphism — how the same method name can behave differently depending on which object calls it.