Kako delujeta dedovanje in super()?

Question

Accepted Answer

**Dedovanje** omogoči razredu, da izpeljava od drugega, ponovno uporablja in razširja njegovo vedenje. **`super()`** pokliče metode nadrejenega razreda. Python podpira **večkratno dedovanje**, rešeno s pomočjo **MRO** (Method Resolution Order).

## Osnovno dedovanje in 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()` omogoči podrazredu, da sprozori vedenje nadrejenega razreda — bistveno v `__init__` za zagon nastavitve nadrejenega in razširitev (ne le zamenjave) preglašenih metod.

## Razširitev v primerjavi s popolno preglašitvijo

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

## Večkratno dedovanje in 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
```

Pri večkratnem dedovanju Python išče metode v specifičnem lineariziranem vrstnem redu — **MRO**, izračunanem s pomočjo algoritma C3. `D.__mro__` ga prikaže; `super()` mu sledi. MRO zagotavlja, da je vsak razred obiskan enkrat in da so nadrejeni prihajajo po podrejenih, kar predvidljivo reši "diamond problem".

## super() sledi MRO (ne le doslovnemu nadrejenemu)

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

## Zakaj je to pomembno

Dedovanje in `super()` so temeljni orodji OOP za ponovno uporabo in razširitev vedenja, uporabljajo se v Python-ogrodjih (npr. podrazredovanje modelov Django, hierarhije izjem).

Razumevanje `super()` (klica logike nadrejenega, še posebej v `__init__`) in **MRO** je posebej pomembno v Pythonu, ker podpira **večkratno dedovanje** — MRO je tisto, kar nareditve razrešitev metod in verige `super()` predvidljive v kompleksnih hierarhijah in primesih.

Znanje, kako deluje MRO (in da mu `super()` sledi), preprečuje zmedo pri diamantnih ali na primesih osnovanih oblikih, ki so pogosti v resničnih Python-kodnih bazah.