super()

super()

What it is

super() returns a proxy object that lets a subclass call a method from the next class in its method resolution order (MRO) — most commonly used to call a parent’s __init__ so the subclass extends rather than completely overrides it.

Before this feature

Calling the parent class by name directly works for simple single inheritance, but hardcodes the parent’s name and breaks down under multiple inheritance:

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

class Dog(Animal):
    def __init__(self, name, breed):
        Animal.__init__(self, name)   # hardcodes the parent class name
        self.breed = breed

After this feature

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)        # no hardcoded parent name
        self.breed = breed

d = Dog("Rex", "Labrador")
print(d.name, d.breed)  # Rex Labrador

# super() also works for calling any method, not just __init__
class Shape:
    def describe(self):
        return "A shape"

class Circle(Shape):
    def describe(self):
        return super().describe() + ", specifically a circle"

print(Circle().describe())  # "A shape, specifically a circle"

Why this is better

• No hardcoded parent name: super().__init__(name) keeps working even if the class hierarchy is later restructured (a new intermediate class inserted, for example).
• Correct under multiple inheritance: super() follows the actual MRO, not just “my literal parent” — essential for cooperative multiple inheritance where each class in a chain should run exactly once (see the MRO page for the full mixin example).
• Extends instead of replaces: calling super().__init__(...) then adding subclass-specific setup is the standard pattern for “do what the parent does, plus a bit more.”

Key notes / edge cases

• In Python 3, super() with no arguments works inside an instance method (it infers the class and instance automatically); the old super(Dog, self) form still works but is rarely needed.
• Forgetting to call super().__init__(...) in a subclass’s __init__ means the parent’s setup (e.g. self.name = name) never runs — a common bug where an inherited attribute is simply missing.
• super() resolves relative to the MRO of the actual instance’s class, not the class where the super() call is written — this is what makes it correct even when called from deep in a multi-level hierarchy.

Quick practice

1. What’s the main advantage of super().__init__(name) over Animal.__init__(self, name)?

   Answer

   It doesn't hardcode the parent class's name, and it follows the MRO correctly under multiple inheritance — `Animal.__init__(self, ...)` always calls exactly that class, which can be wrong or cause a class to run twice in a diamond hierarchy.

2. What happens if a subclass’s __init__ never calls super().__init__(...)?

   Answer

   The parent class's initialization never runs, so any attributes it would have set are simply missing on the instance.

3. Does super() require explicit arguments in Python 3?

   Answer

   No — `super()` with no arguments works inside instance methods; it automatically infers the class and instance from context.