La fonction super() en Python : héritage et classes parentes

En Python, quand une classe hérite d'une autre, elle a besoin d'un moyen d'appeler le code de sa classe parente sans le réécrire. super() remplit ce rôle. Cette fonction intégrée donne accès aux méthodes et attributs de la classe parente depuis une classe enfant. On l'utilise surtout dans les constructeurs pour initialiser les attributs hérités, mais aussi pour étendre n'importe quelle méthode sans dupliquer son code.

Dans ce tutoriel, on part d'un exemple simple pour aller jusqu'à l'héritage multiple et le MRO.

1. La classe parente : point de départ

Avant d'utiliser super(), il faut une classe parente à appeler. Voici une classe Personne avec un constructeur et une méthode d'affichage.

class Personne:
    # Le constructeur reçoit un nom et un âge
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
    # Méthode pour afficher les informations
    def afficher_infos(self):
        print(f"Nom : {self.nom}, Age : {self.age}")

La classe Personne stocke deux informations : le nom et l'âge. La méthode afficher_infos() les affiche. C'est cette base qu'on va réutiliser dans la classe enfant via super().

2. La classe enfant avec super()

La classe Etudiant hérite de Personne. Elle a besoin des mêmes attributs (nom, age) plus un attribut supplémentaire (niveau). Au lieu de réécrire l'initialisation de nom et age, on appelle super().__init__() pour confier ce travail au constructeur parent.

class Etudiant(Personne):
    def __init__(self, nom, age, niveau):
        # super().__init__() appelle le constructeur de Personne
        # Il s'occupe de self.nom et self.age
        super().__init__(nom, age)
        # On ajoute uniquement ce qui est propre à Etudiant
        self.niveau = niveau
    def afficher_infos(self):
        # On réutilise l'affichage de Personne...
        super().afficher_infos()
        # ...puis on ajoute la ligne spécifique à l'étudiant
        print(f"Niveau : {self.niveau}")

Deux utilisations de super() ici. Dans le constructeur, super().__init__(nom, age) délègue l'initialisation des attributs hérités. Dans afficher_infos(), super().afficher_infos() exécute la version parente avant d'ajouter la ligne du niveau.

3. Instanciation et résultat

# Instance de la classe parente
personne1 = Personne("Alice", 30)
personne1.afficher_infos()
# Affiche : Nom : Alice, Age : 30
# Instance de la classe enfant
etudiant1 = Etudiant("Bob", 20, "Bac+2")
etudiant1.afficher_infos()
# Affiche :
# Nom : Bob, Age : 20
# Niveau : Bac+2

Quand on appelle afficher_infos() sur etudiant1, Python exécute d'abord la méthode de Personne via super(), puis complète avec la ligne du niveau — sans qu'on ait eu à réécrire la première.

Exemples avancés

Exemple 1 : Étendre une méthode sans la remplacer

super() ne sert pas qu'aux constructeurs. On peut l'utiliser pour enrichir n'importe quelle méthode héritée. Ici, la classe Chien conserve le comportement de Animal et y ajoute le sien.

class Animal:
    def manger(self):
        print("L'animal mange.")
class Chien(Animal):
    def manger(self):
        # On appelle d'abord la version générale d'Animal
        super().manger()
        # Puis on ajoute le comportement propre au chien
        print("Le chien mange des croquettes et aboie.")

Sans super().manger(), la méthode parente serait écrasée. Avec, on la conserve et on la complète.

Exemple 2 : Héritage de constructeur avec des attributs spécifiques

La classe Voiture hérite de Vehicule et ajoute un modèle. super().__init__() prend en charge les attributs partagés ; on n'initialise manuellement que ceux qui sont nouveaux.

class Vehicule:
    def __init__(self, marque, annee):
        self.marque = marque
        self.annee = annee
class Voiture(Vehicule):
    def __init__(self, marque, annee, modele):
        # marque et annee sont gérés par le constructeur de Vehicule
        super().__init__(marque, annee)
        # modele est propre à Voiture
        self.modele = modele

Si le constructeur de Vehicule évolue, Voiture en hérite sans modification supplémentaire.

Exemple 3 : Héritage multiple et MRO

Python accepte qu'une classe hérite de plusieurs parents. Dans ce cas, super() suit le MRO (Method Resolution Order) — un ordre calculé à la création de la classe. Pour le consulter : Canard.__mro__.

class Volant:
    def se_deplacer(self):
        print("Je vole dans les airs.")
class Nageant:
    def se_deplacer(self):
        print("Je nage dans l'eau.")
# Canard hérite de Volant en premier, puis de Nageant
class Canard(Volant, Nageant):
    def se_deplacer(self):
        # super() appelle Volant.se_deplacer() en suivant le MRO
        super().se_deplacer()
        print("Je peux aussi marcher.")
canard = Canard()
canard.se_deplacer()
# Affiche :
# Je vole dans les airs.
# Je peux aussi marcher.

Canard hérite de Volant avant Nageant — c'est donc Volant.se_deplacer() que super() appelle. Avec class Canard(Nageant, Volant), l'ordre s'inverserait. L'héritage multiple demande une attention particulière à l'ordre des classes dans la définition.

Par carabde | Mis à jour le 29 avril 2026