Jak działają dziedziczenie i super()?

Question

Accepted Answer

**Dziedziczenie** pozwala klasie pochodnej na dziedziczy z innej klasy, ponownie używając i rozszerzając jej zachowanie. **`super()`** wzywa metody klasy nadrzędnej. Python wspiera **wielokrotne dziedziczenie**, rozwiązane przez **MRO** (Method Resolution Order).

## Podstawowe dziedziczenie i 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()` pozwala klasie pochodnej na wywoływanie zachowania klasy nadrzędnej — niezbędne w `__init__` do uruchomienia konfiguracji klasy nadrzędnej i rozszerzenia (nie tylko zastąpienia) przesłoniętych metod.

## Rozszerzenie a całkowite zastąpienie

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

## Wielokrotne dziedziczenie i 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
```

W przypadku wielokrotnego dziedziczenia Python przeszukuje metody w określonej linearyzowanej kolejności — **MRO**, obliczanej przez algorytm C3. `D.__mro__` ją pokazuje; `super()` ją śledzi. MRO gwarantuje, że każda klasa jest odwiedzona raz, a klasy nadrzędne pochodzą po klasach podrzędnych, rozwiązując "diamond problem" w przewidywalny sposób.

## super() podąża za MRO (a nie tylko dosłowną klasą nadrzędną)

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

## Dlaczego to ważne

Dziedziczenie i `super()` to główne narzędzia OOP do ponownego wykorzystania i rozszerzenia zachowania, używane w ramach frameworków Python (np. podklasowanie modeli Django, hierarchie wyjątków).

Zrozumienie `super()` (wywoływanie logiki klasy nadrzędnej, szczególnie w `__init__`) i **MRO** jest szczególnie ważne w Pythonie, ponieważ wspiera on **wielokrotne dziedziczenie** — MRO to to, co sprawia, że rozdzielanie metod i łańcuchy `super()` są przewidywalne w złożonych hierarchiach i mixinach.

Znajomość sposobu działania MRO (i że `super()` go śledzi) zapobiega zamieszaniu w projektach o strukturze diamentoidalnej lub opartych na mixinach, które są powszechne w rzeczywistych bazach kodu Pythona.