Introduction

super() is Python’s way to continue a method call along the method resolution order, or MRO. In __init__ methods that matters because object construction often needs cooperation from several classes, especially once inheritance becomes more than a simple single-parent case.

In Single Inheritance, super() Reuses Parent Initialization

The simplest case is a subclass that extends a base class:

1class Animal:
2    def __init__(self, name):
3        self.name = name
4        print(f"Animal init for {name}")
5
6
7class Dog(Animal):
8    def __init__(self, name, breed):
9        super().__init__(name)
10        self.breed = breed
11        print(f"Dog init for {breed}")
12
13
14dog = Dog("Milo", "beagle")
15print(dog.name, dog.breed)

Output:

Animal init for Milo
Dog init for beagle
Milo beagle

Here, super().__init__(name) runs the next __init__ in the MRO, which in this simple example is the parent class Animal.

super() Means “Next in MRO,” Not “My Parent by Name”

That distinction becomes important with multiple inheritance. Consider this example:

1class A:
2    def __init__(self):
3        print("A")
4        super().__init__()
5
6
7class B(A):
8    def __init__(self):
9        print("B")
10        super().__init__()
11
12
13class C(A):
14    def __init__(self):
15        print("C")
16        super().__init__()
17
18
19class D(B, C):
20    def __init__(self):
21        print("D")
22        super().__init__()
23
24
25print(D.__mro__)
26D()

Output:

1(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
2D
3B
4C
5A

super() in B does not jump straight to A. It goes to the next class in D’s MRO, which is C. That is why directly naming parent classes often breaks cooperative multiple inheritance.

Cooperative __init__ Methods Need Compatible Signatures

For cooperative inheritance to work well, each class should:

• accept the arguments it needs
• pass remaining arguments onward
• call super().__init__

Example:

1class Named:
2    def __init__(self, *, name, **kwargs):
3        self.name = name
4        super().__init__(**kwargs)
5
6
7class Colored:
8    def __init__(self, *, color, **kwargs):
9        self.color = color
10        super().__init__(**kwargs)
11
12
13class Widget(Named, Colored):
14    def __init__(self, *, name, color):
15        super().__init__(name=name, color=color)
16
17
18w = Widget(name="button", color="blue")
19print(w.name, w.color)

This pattern avoids duplicate initialization and lets each class consume only its own parameters.

Why Direct Base-Class Calls Can Be a Problem

You can write:

Animal.__init__(self, name)

and in a simple inheritance tree that may appear to work. The problem is that direct base-class calls do not cooperate with the MRO. In a diamond-shaped hierarchy, that can lead to:

• duplicated initialization
• skipped classes
• tightly coupled code that breaks during refactors

super() exists to support cooperative dispatch across the full class hierarchy rather than hard-coding one parent call at a time.

Practical Rule of Thumb

If the class participates in inheritance and especially if multiple inheritance is possible, use super() consistently in every class in the chain.

If one class skips super() while the others use it, the chain stops there. That often creates confusing bugs because part of the object ends up initialized and part does not.

Common Pitfalls

The biggest mistake is assuming super() means “call my immediate parent class.” In Python it means “call the next implementation according to the MRO.”

Another common issue is mixing cooperative and non-cooperative classes. If some classes call super() and others directly name base classes, the initialization flow becomes fragile.

Developers also sometimes forget to design compatible __init__ signatures. Cooperative multiple inheritance works best when classes accept **kwargs and forward what they do not consume.

Finally, do not ignore __mro__. When behavior feels surprising, printing the MRO often explains exactly why super() is calling classes in a certain order.

Summary

• In __init__, super() continues along the method resolution order.
• In single inheritance, that usually looks like a parent-class call.
• In multiple inheritance, the MRO determines what runs next.
• Cooperative classes should call super() and forward unused arguments cleanly.
• Direct base-class calls can work in simple cases, but they are risky in reusable hierarchies.