Jak fungují dědičnost a `super()`?

Question

Accepted Answer

**Dědičnost** umožňuje třídě dědit z jiné třídy a znovu používat a rozšiřovat její chování. **`super()`** volá metody rodičovské třídy. Python podporuje **vícenásobnou dědičnost**, kterou řeší **MRO** (Method Resolution Order).

## Základní dědičnost a 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()` umožňuje podtřídě vyvolat chování rodiče — nezbytné v `__init__` ke spuštění nastavení rodiče a k rozšíření (nikoli pouhé nahrazení) přepsaných metod.

## Rozšiřování vs. úplné přepsání

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

## Vícenásobná dědičnost a 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
```

Při vícenásobné dědičnosti Python vyhledává metody v určitém linearizovaném pořadí — **MRO**, vypočítaném algoritmem C3. `D.__mro__` jej zobrazuje; `super()` jej následuje. MRO zajišťuje, že každá třída je navštívena jednou a rodiče přicházejí po dětech, což řeší "problém diamantu" předvídatelně.

## super() následuje MRO (nikoli jen doslova rodiče)

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

## Proč na tom záleží

Dědičnost a `super()` jsou základní nástroje OOP pro opakované použití a rozšíření chování, používané v celých Python frameworcích (např. podtřídy Django modelů, hierarchie výjimek).

Porozumění `super()` (volání logiky rodiče, zejména v `__init__`) a **MRO** je v Pythonu zvláště důležité, protože podporuje **vícenásobnou dědičnost** — MRO je to, co činí řešení metod a řetězce `super()` předvídatelnými ve složitých hierarchiích a mixinech.

Znalost toho, jak MRO funguje (a že `super()` ji následuje), zabraňuje zmatení v diamantových nebo mixin-založených návrzích, které jsou běžné v reálných Python kódech.