Conas a oibríonn oidhreachta agus super() ?

Question

Accepted Answer

**Oidhreachta** a ligeann do rang a fhál ó rang eile, ag atúsáil agus ag síneadh a iompair. **`super()`** glaonna ar dhóanna an rang tuismitheora. Tacaíonn Python le **oidhreachta iolrach**, réitithe ag an **MRO** (Ord Réiteachais Modh).

## Oidhreachta agus super() bunúsach

```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()` a ligeann do fhofhocal an iompair tuismitheora a agairt — riachtanach i `__init__` chun socrú an tuismitheora a rith, agus chun (ní amháin a athsholáthar) modhanna forscríofa a leathnú.

## Leathnú i gcomparáid le bheith ag forghníomhú go hiomlán

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

## Oidhreachta iolrach agus an 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
```

Le oidhreachta iolrach, cuardaíonn Python do dhóanna in ord línithe sonrach — an **MRO**, arna ríomh ag an algartam C3. Taispeánann `D.__mro__` é; leanann `super()` é. Cinntíonn an MRO go bhéartófar gach rang aon uair amháin agus go gcumhdófar tuismitheoirí tar éis páistí, ag socrú an "fhadhb dhiamainte" go tuartha.

## super() a leanann an MRO (ní amháin an tuismitheoir litriúil)

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

## Cén fáth a bhfuil tábhacht ann

Is uirlisí bunúsacha OOP iad oidhreachta agus `super()` chun iompair a atúsáil agus a leathnú, agus úsáidtear iad ar fud fhreamhbhlaoichí Python (m.sh. subclassing Django líonainn, leathchaiseanna eisceachta).

Tá a thuiscint ar `super()` (loighic tuismitheora a ghlaoch, go háirithe i `__init__`) agus ar an **MRO** go háirithe tábhachtach i Python toisc go bhacann sé **oidhreachta iolrach** — is é an MRO a dhéanann réiteach modh agus slabhraí `super()` intuigthe i ranganna casta agus meascthaiscéim.

An bhraistint ar conas an MRO ag obair (agus go leanann `super()` é) a bhíonn dúntais i ndearaibh shapáilte diamuinte nó meascthaiscéim-bhunaithe atá coiteann i stóras Python fíor-dhomhanda.