Comment fonctionnent l'héritage et `super()` ?

Question

Accepted Answer

**L'héritage** permet à une classe de dériver d'une autre, en réutilisant et en étendant son comportement. **`super()`** appelle les méthodes de la classe parente. Python supporte **l'héritage multiple**, résolu par **MRO** (Method Resolution Order).

## Héritage basique et 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()` permet à une sous-classe d'invoquer le comportement parental — essentiel dans `__init__` pour exécuter la configuration de la classe parente, et pour étendre (et non simplement remplacer) les méthodes écrasées.

## Extension vs remplacement complet

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

## Héritage multiple et le 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
```

Avec l'héritage multiple, Python recherche les méthodes dans un ordre linéarisé spécifique — le **MRO**, calculé par l'algorithme C3. `D.__mro__` l'affiche ; `super()` le suit. Le MRO garantit que chaque classe est visitée une fois et que les parents arrivent après les enfants, résolvant le "problème du diamant" de manière prévisible.

## super() suit le MRO (pas seulement la classe parente littérale)

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

## Pourquoi c'est important

L'héritage et `super()` sont des outils OOP essentiels pour réutiliser et étendre le comportement, utilisés partout dans les frameworks Python (par exemple, les sous-classes de modèles Django, les hiérarchies d'exceptions).

Comprendre `super()` (appeler la logique parente, surtout dans `__init__`) et le **MRO** est particulièrement important en Python car il supporte **l'héritage multiple** — le MRO est ce qui rend la résolution des méthodes et les chaînes `super()` prévisibles dans les hiérarchies complexes et les mixins.

Savoir comment le MRO fonctionne (et que `super()` le suit) évite la confusion dans les conceptions en forme de diamant ou basées sur les mixins, qui sont courantes dans les vrais projets Python.