Wie funktionieren Vererbung und `super()`?

Question

Accepted Answer

**Vererbung** ermöglicht es einer Klasse, von einer anderen abzuleiten und ihr Verhalten wiederzuverwenden und zu erweitern. **`super()`** ruft Methoden der Elternklasse auf. Python unterstützt **Mehrfachvererbung**, aufgelöst durch **MRO** (Method Resolution Order).

## Warum es wichtig ist

```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()` ermöglicht es einer Subklasse, das Verhalten des Elternteils aufzurufen — in `__init__` essentiell, um das Setup des Elternteils auszuführen und überschriebene Methoden zu erweitern (nicht nur zu ersetzen).

## Erweitern vs. vollständiges Überschreiben

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

## Mehrfachvererbung und die 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
```

Bei Mehrfachvererbung durchsucht Python Methoden in einer spezifischen linearisierten Ordnung — die **MRO**, berechnet durch den C3-Algorithmus. `D.__mro__` zeigt sie; `super()` folgt ihr. Die MRO stellt sicher, dass jede Klasse einmal besucht wird und Eltern nach Kindern kommen, was das "Diamond Problem" vorhersehbar löst.

## super() folgt der MRO (nicht nur dem wörtlichen Elternteil)

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

## Warum es wichtig ist

Vererbung und `super()` sind zentrale OOP-Werkzeuge zum Wiederverwenden und Erweitern von Verhalten, die in Python-Frameworks verwendet werden (z. B. Subklassen von Django-Modellen, Ausnahmehierarchien).

Das Verständnis von `super()` (Aufrufen der Elternlogik, besonders in `__init__`) und **MRO** ist in Python besonders wichtig, da es **Mehrfachvererbung** unterstützt — die MRO ist das, was Methodenauflösung und `super()`-Ketten in komplexen Hierarchien und Mixins vorhersehbar macht.

Das Wissen, wie die MRO funktioniert (und dass `super()` ihr folgt), verhindert Verwirrung in diamantförmigen oder mixin-basierten Designs, die in echten Python-Codebasen häufig sind.