Kaip veikia paveldėjimas ir super()?

Question

Accepted Answer

**Paveldėjimas** leidžia klasei perimti iš kitos klasės, naudojant jos veikseną ir ją plečiant. **`super()`** iškviečia tėrinės klasės metodais. Python palaiko **daugkartinį paveldėjimą**, kuris sprendžiamas naudojant **MRO** (Method Resolution Order).

## Pagrindinė paveldėjimas ir 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()` leidžia poklasui iškviesti tėrinės veiksenos — būtina `__init__` pradėti tėrinę sąranką ir išplėsti (ne tik pakeisti) perrašytus metodus.

## Plėtimas ir visas perrašymas

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

## Daugkartinis paveldėjimas ir 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
```

Su daugkartiniu paveldėjimu Python ieško metodų tam tikra tiesine tvarka — **MRO**, apskaičiuota C3 algoritmu. `D.__mro__` jį rodo; `super()` sekite. MRO užtikrina, kad kiekviena klasė būtų aplankyta kartą, o tėvai patektų po vaikų, numatymai "deimanto problemos" sprendimas.

## super() seka MRO (ne tik aiškų tėvą)

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

## Kodėl tai svarbu

Paveldėjimas ir `super()` yra pagrindiniai OOP įrankiai veiksenai naudoti ir ją plėsti, naudojami per visą Python sistemų (pvz., Django modelių subklasifikacija, išimčių hierarchija).

Supratimas `super()` (tėrinio logikos iškviečimas, ypač `__init__` jei) ir **MRO** yra ypač svarbu Python, nes jis palaiko **daugkartinį paveldėjimą** — MRO yra tai, kas daro metodo sprendimą ir `super()` grandinę numatomas sudėtingose hierarchijose ir mišiniuose.

Žinojimas, kaip veikia MRO (ir kad `super()` sekite) ima sumažinti painiavą deimanto formos ar mišinio paremtame dizaine, kuris yra bendras tikrame Python kode.