B.2 Le polymorphisme : un même appel, des comportements différents

1Situer

Un atelier de menuiserie à Tétouan calcule la surface de bois nécessaire pour ses commandes : des plateaux rectangulaires, des tables rondes, des étagères triangulaires. Le programme doit parcourir toutes les pièces d'une commande et additionner leurs aires, sans écrire un « si c'est un cercle alors... sinon si c'est un rectangle... ». C'est exactement ce que permet le polymorphisme.

2Comprendre

Polymorphisme : le même appel, des calculs différents

La commande contient trois pièces de classes différentes. La boucle appelle piece.aire() sur chacune.

1 / 5

Polymorphisme veut dire « plusieurs formes ». Un même appel, piece.aire(), déclenche un calcul différent selon la classe réelle de l’objet.

La redéfinition de méthode

Une classe fille peut redéfinir (override) une méthode héritée : elle écrit une méthode de même nom qui remplace celle de la mère. Pour réutiliser la version de la mère, on appelle super().methode().

for piece in commande:
    total += piece.aire()   # Rectangle.aire() ou Disque.aire()

Ajouter une nouvelle sorte de pièce ne demande aucune modification de la boucle : c’est l’intérêt principal du polymorphisme.

Exemple simple

Chaque animal a son cri

La classe fille réécrit une méthode du parent avec le même nom. Le bon cri est choisi selon l’objet.

class Animal:
    def cri(self):
        return "..."
class Chat(Animal):
    def cri(self):
        return "Miaou"
class Chien(Animal):
    def cri(self):
        return "Wouf"

for a in [Chat(), Chien(), Animal()]:
    print(a.cri())

Résultat

Miaou
Wouf
...

Ce qui se passe

La boucle appelle toujours a.cri(), sans savoir quel animal c’est.
Python cherche d’abord cri() dans la classe de l’objet, puis dans le parent.

La surcharge de méthode

En Java ou en C#, on peut écrire plusieurs méthodes de même nom avec des paramètres différents. En Python, la dernière définie gagne. On obtient le même résultat avec des paramètres par défaut :

def aire(self, unite="m2"):
    ...

Exemple simple

Une méthode qui accepte un ou deux paramètres

Python n’a pas de vraie surcharge : on obtient le même effet avec des valeurs par défaut.

class Calcul:
    def aire(self, a, b=None):
        if b is None:
            return a * a        # carré
        return a * b            # rectangle

c = Calcul()
print(c.aire(4), c.aire(4, 3))  # 16 12

Ce qui se passe

aire(4) : b vaut None, on calcule un carré.
aire(4, 3) : on calcule un rectangle.

La surcharge d’opérateurs

Python appelle des méthodes spéciales quand on utilise un opérateur sur un objet :

Écriture	Méthode appelée
`a + b`	`a.__add__(b)`
`a == b`	`a.__eq__(b)`
`a < b`	`a.__lt__(b)`
`print(a)`	`a.__str__()`
`len(a)`	`a.__len__()`

En les définissant, vos objets s’utilisent aussi naturellement que des nombres ou des chaînes.

Exemple simple

Additionner deux sommes d’argent avec +

En écrivant __add__, on décide ce que fait le signe + entre deux objets.

class Montant:
    def __init__(self, dh):
        self.dh = dh
    def __add__(self, autre):
        return Montant(self.dh + autre.dh)
    def __str__(self):
        return f"{self.dh} DH"

print(Montant(150) + Montant(75))

Résultat

225 DH

Ce qui se passe

Montant(150) + Montant(75) appelle Montant(150).__add__(Montant(75)).
La méthode crée un nouveau Montant avec la somme.
print utilise __str__ pour l’afficher joliment.

Exemple simple

« Fais ton cri »

Demandez à un chat, un chien et un coq de « faire leur cri » : chacun répond à sa manière. La demande est la même, la réponse dépend de l'animal.

for animal in [Chat(), Chien(), Coq()]:
    animal.crier()   # Miaou / Ouaf / Cocorico

Exemple simple

Le + qui s'adapte

En Python, + additionne des nombres, colle des textes et fusionne des listes. C'est déjà du polymorphisme : le même opérateur se comporte selon le type.

print(2 + 3)             # 5
print("Dar" + "ija")     # Darija
print([1, 2] + [3])      # [1, 2, 3]

3Manipuler

Exécutez. Une seule boucle calcule toutes les aires. Ajoutez une classe Triangle(base, hauteur) avec sa propre méthode aire(), mettez un triangle dans la commande, et relancez : la boucle n'a pas besoin de changer.

Pas à pas dans le lab ↗Python se charge au premier clic (environ 12 Mo, une seule fois).

import math

class Piece:
    def __init__(self, nom):
        self.nom = nom

def aire(self):
        return 0

# Surcharge de l'affichage
    def __str__(self):
        return f"{self.nom} : {self.aire():.2f} m²"

class Rectangle(Piece):
    def __init__(self, nom, largeur, longueur):
        super().__init__(nom)
        self.largeur, self.longueur = largeur, longueur

def aire(self):                       # redéfinition
        return self.largeur * self.longueur

class Disque(Piece):
    def __init__(self, nom, rayon):
        super().__init__(nom)
        self.rayon = rayon

def aire(self):                       # redéfinition
        return math.pi * self.rayon ** 2

commande = [
    Rectangle("Plateau", 0.8, 1.6),
    Disque("Table ronde", 0.6),
    Rectangle("Étagère", 0.3, 1.2),
]

total = 0
for piece in commande:          # polymorphisme : chaque pièce
    print(piece)                # sait calculer sa propre aire
    total += piece.aire()
print(f"Bois nécessaire : {total:.2f} m²")

Entrées pour input(), séparées par des virgules

Console

Mémoire : objets créés

Exécutez le code : les objets et leurs attributs s'afficheront ici.

4Pratiquer

Exercice 1 · Le triangle

Ajoutez la classe Triangle(nom, base, hauteur) avec sa méthode aire(). Vérifiez que la boucle de la commande fonctionne sans modification.

Voir le corrigé

class Triangle(Piece):
    def __init__(self, nom, base, hauteur):
        super().__init__(nom)
        self.base, self.hauteur = base, hauteur

    def aire(self):
        return self.base * self.hauteur / 2

commande.append(Triangle("Équerre", 0.4, 0.4))

Exercice 2 · Surcharge d'opérateur

Écrivez une classe Prix(montant) dont les objets s'additionnent avec + et se comparent avec <. Testez Prix(20) + Prix(15) et Prix(20) < Prix(15).

Voir un indice

Les méthodes spéciales s'appellent __add__ et __lt__.

Voir le corrigé

class Prix:
    def __init__(self, montant):
        self.montant = montant
    def __add__(self, autre):
        return Prix(self.montant + autre.montant)
    def __lt__(self, autre):
        return self.montant < autre.montant
    def __str__(self):
        return f"{self.montant} DH"

print(Prix(20) + Prix(15))   # 35 DH
print(Prix(20) < Prix(15))   # False

Exercice 3 · Redéfinir en gardant le comportement parent

Dans une classe Taxi(Voiture), redéfinissez decrire() pour ajouter « (taxi) » à la description de la classe mère, sans la recopier.

Voir le corrigé

class Taxi(Voiture):
    def decrire(self):
        return super().decrire() + " (taxi)"

Le polymorphisme : un même appel, des comportements différents

1Situer

2Comprendre

La redéfinition de méthode

La surcharge de méthode

La surcharge d’opérateurs

« Fais ton cri »

Le + qui s'adapte

3Manipuler

4Pratiquer

Exercice 1 · Le triangle

Exercice 2 · Surcharge d'opérateur

Exercice 3 · Redéfinir en gardant le comportement parent

5Vérifier