L'héritage en Python : réutiliser et étendre vos classes

L'héritage en Python : à quoi ça sert ?

En programmation orientée objet, l'héritage permet à une classe de reprendre le comportement d'une autre. Si une classe existe déjà et fait ce qu'il faut, on n'en recrée pas une de zéro : on en hérite et on n'ajoute que ce qui diffère.

Deux rôles dans cette relation :

• La classe parent (ou classe de base) : celle qui contient la logique commune.
• La classe enfant (ou classe dérivée) : celle qui hérite et qu'on peut enrichir.

L'héritage réduit la duplication et rend le code plus facile à maintenir quand la structure évolue.

Créer une classe parent

Une classe parent s'écrit comme n'importe quelle autre classe. Rien ne la distingue syntaxiquement — c'est son usage dans la hiérarchie qui lui donne ce rôle.

La classe Personne ci-dessous stocke un prénom et un nom, et propose une méthode pour les afficher :

class Personne:
    def __init__(self, fname, lname):
        self.prenom = fname
        self.nom = lname

    def affichenom(self):
        print(self.prenom, self.nom)

# Création d'un objet Personne et appel de la méthode
x = Personne("Anass", "Le Forgeron")
x.affichenom()

Créer une classe enfant

Pour qu'une classe hérite d'une autre, il suffit d'indiquer le nom de la classe parent entre parenthèses à la définition. La classe enfant récupère alors tous les attributs et toutes les méthodes du parent.

Si rien n'est ajouté pour l'instant, le mot-clé pass permet de créer une classe vide valide :

class Etudiant(Personne):
    pass  # hérite de tout sans rien ajouter

La classe Etudiant peut maintenant utiliser affichenom() et accéder à prenom et nom, même si ces éléments sont définis dans Personne :

class Personne:
    def __init__(self, fname, lname):
        self.prenom = fname
        self.nom = lname

    def affichenom(self):
        print(self.prenom, self.nom)

class Etudiant(Personne):
    pass

# Etudiant hérite de Personne : affichenom() fonctionne sans être redéfinie
x = Etudiant("Anass", "Le Forgeron")
x.affichenom()

Résultat : Anass Le Forgeron. La méthode n'est définie nulle part dans Etudiant, pourtant elle fonctionne.

Ajouter la fonction __init__() dans la classe enfant

La méthode __init__() est le constructeur : Python l'appelle automatiquement à chaque création d'objet. Tant qu'on n'en définit pas dans la classe enfant, celle du parent s'exécute.

Dès qu'on en déclare une dans la classe enfant, elle remplace celle du parent. Pour ne pas perdre l'initialisation d'origine, il faut appeler explicitement le constructeur parent :

class Etudiant(Personne):
    def __init__(self, fname, lname):
        # Appel explicite du constructeur de Personne
        Personne.__init__(self, fname, lname)

Remarque : sans cet appel, les attributs prenom et nom ne sont pas initialisés — vous obtiendrez une erreur à l'exécution.

La fonction super() : la façon recommandée

super() fait référence à la classe parent sans qu'on ait à écrire son nom en dur. Si la classe parent est renommée un jour, le code reste valide sans aucune modification.

class Etudiant(Personne):
    def __init__(self, fname, lname):
        # super() transmet automatiquement les arguments au parent
        super().__init__(fname, lname)

Si Personne est un jour renommée en Individu, la ligne super().__init__() continue de fonctionner — ce qui n'est pas le cas avec Personne.__init__(self, ...).

Ajouter des propriétés spécifiques à la classe enfant

Une fois le constructeur parent appelé via super(), on peut ajouter les attributs propres à la classe enfant. Ici, annee_du_diplome n'a de sens que pour un étudiant :

class Etudiant(Personne):
    def __init__(self, fname, lname, annee):
        super().__init__(fname, lname)
        # Attribut propre à Etudiant, absent de Personne
        self.annee_du_diplome = annee

x = Etudiant("Anass", "Le Forgeron", 2021)

Ajouter des méthodes spécifiques à la classe enfant

On peut aussi définir des méthodes qui n'existent que dans la classe enfant. La méthode Bienvenue() combine des attributs hérités (prenom, nom) et un attribut propre (annee_du_diplome) :

class Personne:
    def __init__(self, fname, lname):
        self.prenom = fname
        self.nom = lname

    def affichenom(self):
        print(self.prenom, self.nom)

class Etudiant(Personne):
    def __init__(self, fname, lname, annee):
        super().__init__(fname, lname)
        self.annee_du_diplome = annee

    def Bienvenue(self):
        # Utilise à la fois les attributs hérités et l'attribut propre
        print("Bienvenue", self.prenom, self.nom, "dans le club de", self.annee_du_diplome)

x = Etudiant("Anass", "Le Forgeron", 2021)
x.Bienvenue()

Résultat : Bienvenue Anass Le Forgeron dans le club de 2021.

Attention : si une méthode de la classe enfant porte le même nom qu'une méthode du parent, la version parent est écrasée — c'est la surcharge de méthode. C'est parfois intentionnel, parfois non.

Par carabde | Mis à jour le 29 avril 2026