How do inheritance and super() work?

Question

Accepted Answer

**Inheritance** lets a class derive from another, reusing and extending its behavior. **`super()`** calls the parent class's methods. Python supports **multiple inheritance**, resolved by the **MRO** (Method Resolution Order).

## Basic inheritance and super()

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` lets a subclass invoke parent behavior — essential in `__init__` to run the parent's setup, and to extend (not just replace) overridden methods.

## Extending vs fully overriding

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Multiple inheritance and the MRO

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

With multiple inheritance, Python searches for methods in a specific linearized order — the **MRO**, computed by the C3 algorithm. `D.__mro__` shows it; `super()` follows it. The MRO ensures each class is visited once and parents come after children, resolving the "diamond problem" predictably.

## super() follows the MRO (not just the literal parent)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## Why it matters

Inheritance and `super()` are core OOP tools for reusing and extending behavior, used throughout Python frameworks (e.g. subclassing Django models, exception hierarchies).

Understanding `super()` (calling parent logic, especially in `__init__`) and the **MRO** is especially important in Python because it supports **multiple inheritance** — the MRO is what makes method resolution and `super()` chains predictable in complex hierarchies and mixins.

Knowing how the MRO works (and that `super()` follows it) prevents confusion in diamond-shaped or mixin-based designs that are common in real Python codebases.