Lorsqu'une classe hérite d'une classe parente, la classe enfant peut avoir ses propres variables d'instance et méthodes, mais parfois elle doit quand même utiliser certaines parties du code du parent.

C'est là qu'intervient la fonction super().
Elle permet à la classe enfant d'accéder aux méthodes (et indirectement aux attributs) de sa classe parente — sans avoir à coder en dur le nom du parent.

L'une des utilisations les plus courantes de super() est d'appeler le constructeur du parent (__init__) depuis la classe enfant, pour que le parent puisse configurer ses propres attributs avant que l'enfant n'ajoute les siens.

Lorsque vous créez une classe enfant qui définit sa propre méthode init, elle remplace celle du parent. Cela signifie que lorsque vous créez un objet depuis la classe enfant, seule la méthode init de l'enfant s'exécute — le constructeur du parent n'est pas appelé automatiquement. Par conséquent, toute logique d'initialisation, valeurs par défaut ou attributs définis dans le init du parent seront complètement ignorés, ce qui les laisse indéfinis dans l'objet enfant. Cela peut causer des erreurs inattendues si la classe parente était responsable d'une initialisation importante. Pour éviter de perdre ce comportement, vous devez appeler super().init() à l'intérieur du constructeur de l'enfant, ce qui exécute explicitement l'initialisation du parent avant d'ajouter ou de modifier quoi que ce soit dans l'enfant.

Explorons cela maintenant !

Pourquoi utiliser super().__init__() ?

Quand vous créez une sous-classe, vous pouvez lui donner des données supplémentaires à stocker.
Cependant, vous voulez toujours que les attributs du parent soient initialisés correctement. Au lieu de réécrire le code d'initialisation du parent, vous l'appelez simplement avec super().__init__().

Exemple : Ajouter un nouvel attribut dans une sous-classe

Supposons que nous ayons une classe Animal qui stocke name et age.
Nous voulons créer une sous-classe Dog qui stocke aussi la breed (race) du chien, mais nous voulons toujours utiliser le constructeur d’Animal pour définir name et age.

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # Appelle le constructeur d'Animal
        self.breed = breed           # Ajoute l'attribut propre à Dog

Fonctionnement étape par étape

1. Quand on crée un objet Dog, Python exécute la méthode __init__ de la classe Dog.
2. Dans Dog.__init__, la ligne super().__init__(name, age) appelle Animal.__init__.
3. Le constructeur parent (Animal.__init__) définit self.name et self.age.
4. Le contrôle revient à Dog.__init__, qui définit alors self.breed.

Ainsi:

• Les attributs du parent sont initialisés exactement comme il l’a prévu.
• La classe enfant peut ajouter ses propres attributs sans dupliquer le code.

Utilisation de la classe

dog = Dog("Rex", 4, "Golden Retriever")

print(dog.name)   # Rex
print(dog.age)    # 4
print(dog.breed)  # Golden Retriever

Pourquoi super() est préférable à appeler le parent par son nom

Vous pourriez appeler Animal.__init__(self, name, age) directement, mais utiliser super() est plus flexible :

• Il gère automatiquement l'héritage multiple (si votre classe hérite de plusieurs parents).
• Il rend votre code plus facile à maintenir — si vous renommez la classe parente, vous n'avez pas à modifier chaque appel.
• Il communique clairement que vous appelez intentionnellement une méthode de la classe parente.

ASTUCE : Appelez toujours `super().__init__()` avant de définir les attributs propres à l'enfant, afin que tous les attributs du parent soient prêts à être utilisés.

En résumé

super() est votre lien avec la classe parente. Utilisez-le quand vous voulez :

• Réutiliser le code d'initialisation du parent.
• Étendre la fonctionnalité du parent sans la dupliquer.
• Garder votre code propre, maintenable et prêt pour des changements dans la hiérarchie des classes.

Dans la prochaine leçon, nous explorerons les méthodes et variables privées — une façon de protéger les données internes de votre classe contre l'accès ou la modification depuis l'extérieur.