`super()` — calling parent methods

WHAT is super()?

So instead of:

class Dog(Animal):
    def __init__(self, name):
        Animal.__init__(self, name)   # hard-coded parent name

you write:

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)        # decoupled from parent name

WHY does it exist? (the problem it solves)

HOW it works — derived from first principles

There is no magic. super() is just Parent.method(self) but with the parent chosen dynamically via the MRO.

Step 1 — every class has an MRO. Python computes a linear order of classes to search for an attribute. View it:

Dog.__mro__   # (Dog, Animal, object)

Step 2 — super() inside a method of class C means:

"Start searching the MRO of type(self) at the position right after C, and bind self."

Step 3 — derive the equivalence. Inside Dog.__init__, super() is conceptually: $\texttt{super()} \equiv \texttt{super(Dog, self)}$ which finds the next class after Dog in type(self).__mro__ (here Animal) and calls its method with self already supplied. That's why you write super().__init__(name) and not super().__init__(self, name) — self is injected automatically.

Worked Example 1 — extending __init__

class Animal:
    def __init__(self, name):
        self.name = name
        self.legs = 4
 
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)   # parent sets name + legs
        self.breed = breed       # child adds extra state
 
d = Dog("Rex", "Lab")
print(d.name, d.legs, d.breed)   # Rex 4 Lab

• Why super().__init__(name) first? So self.name and self.legs exist before the child adds its own attributes — child extends, doesn't replace.
• Why no self? The proxy already bound self; passing it again gives a "got multiple values for argument" error.

Worked Example 2 — extending a normal method

class Logger:
    def save(self, data):
        print("validating", data)
        return True
 
class TimestampLogger(Logger):
    def save(self, data):
        ok = super().save(data)      # reuse parent's validation
        print("saved at 12:00", data)
        return ok

• Why call super().save instead of copying validation? If validation logic changes in Logger, the child stays correct automatically (single source of truth).

Worked Example 3 — multiple inheritance & the MRO

class A:
    def __init__(self): print("A"); super().__init__()
class B(A):
    def __init__(self): print("B"); super().__init__()
class C(A):
    def __init__(self): print("C"); super().__init__()
class D(B, C):
    def __init__(self): print("D"); super().__init__()
 
D()                 # prints D B C A  (each ONCE)
print([c.__name__ for c in D.__mro__])  # D B C A object

• Why D B C A and not D B A C A? Because super() in B does not mean "go to A" — it means "go to the next class in D's MRO," which is C. The MRO guarantees A runs exactly once. This is the killer feature you can't get with A.__init__(self).

Flashcards

Connections

• Inheritance — extending classes
• Method Resolution Order (MRO) & C3 Linearization
• Method Overriding vs Overloading
• Multiple Inheritance & the Diamond Problem
• `__init__` — constructors
• Composition over Inheritance

Concept Map

Hinglish (regional understanding)