Formations — 1 037 leçons en français

Accueil › Python › Héritage ou composition : lequel choisir

Héritage ou composition : lequel choisir

Classes et objetsintermediaire

Deux façons de réutiliser du code, et elles ne se valent pas.

L'héritage fait de votre classe une variante du parent :

class Produit:
    def __init__(self, reference: str, prix: float) -> None:
        self.reference = reference
        self.prix = prix

    def frais_de_port(self) -> float:
        return 4.90

class ProduitNumerique(Produit):
    def frais_de_port(self) -> float:
        return 0.0

La composition fait de votre classe un assemblage :

class Produit:
    def __init__(self, reference: str, prix: float, livraison: Livraison) -> None:
        self.reference = reference
        self.prix = prix
        self.livraison = livraison          # on délègue

    def frais_de_port(self) -> float:
        return self.livraison.frais(self.prix)

La composition gagne le plus souvent, pour trois raisons concrètes :

L'héritage a un coût qui ne se voit pas tout de suite : la sous-classe dépend de la façon dont les méthodes du parent s'appellent entre elles. Modifiez cette mécanique interne, et des sous-classes que vous n'avez pas sous les yeux cassent. C'est le problème de la fragile base class.

Héritez quand la relation est vraiment « est un », que l'interface du parent s'applique entièrement, et qu'un objet ne changera jamais de catégorie. Dans les autres cas, composez.

Les termes à connaître

Héritage

class ProduitNumerique(Produit) : la sous-classe reçoit tous les attributs et méthodes de la classe parente et peut en redéfinir. Relation « est un », et couplage fort : la sous-classe dépend des choix internes du parent.

Composition

Un objet contient un autre objet et lui délègue une partie du travail : self.tarif = GrilleTarifaire(...). Relation « a un », couplage faible, remplaçable à l'exécution.

`super()`

Donne accès à l'implémentation suivante dans l'ordre de résolution — pas forcément la classe parente directe en héritage multiple. super().__init__(...) est l'appel qui manque le plus souvent dans un __init__ de sous-classe.

MRO (Method Resolution Order)

L'ordre dans lequel Python cherche un attribut à travers les classes parentes, calculé par linéarisation C3 et consultable via MaClasse.__mro__. Il garantit qu'une classe passe avant ses propres parents.

Duck typing

« Si ça fait coin-coin, c'est un canard » : Python n'exige pas un type parent commun, seulement les bonnes méthodes. C'est ce qui rend l'héritage beaucoup moins nécessaire qu'en Java ou en C#.

Protocol

typing.Protocol décrit un ensemble de méthodes attendues, sans héritage. Un objet qui les possède satisfait le protocole — le typage statique rattrape ainsi le duck typing.

Classe de base abstraite (ABC)

Une classe héritant de abc.ABC avec des méthodes @abstractmethod. On ne peut pas l'instancier : TypeError: Can't instantiate abstract class PaiementCarte without an implementation for abstract method 'payer'.

Fragile base class

Le problème de fond de l'héritage : modifier la classe parente casse des sous-classes qu'on n'a pas sous les yeux, parce qu'elles dépendent de la façon dont ses méthodes s'appellent entre elles.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.