B.3 L'abstraction : classes et méthodes abstraites

1Situer

Un site de vente en ligne accepte plusieurs moyens de paiement : carte bancaire, paiement à la livraison, virement. Chaque moyen a sa propre façon de payer, mais tous doivent avoir une méthode payer(montant). Si un développeur oublie de l'écrire pour un nouveau moyen, l'erreur doit être détectée tout de suite, pas le jour où un client paie.

2Comprendre

La classe abstraite fixe le contrat

Paiement est une classe abstraite : elle déclare payer() sans l'écrire. C'est un contrat pour toutes ses filles.

1 / 5

L’abstraction consiste à ne garder que l’essentiel : on décrit ce que les objets d’une famille savent faire, sans dire comment. Chaque classe concrète fournit le comment.

Classe abstraite et méthode abstraite

En Python, on hérite de ABC et on marque les méthodes avec @abstractmethod :

from abc import ABC, abstractmethod

class Paiement(ABC):
    @abstractmethod
    def payer(self, montant):
        ...

Deux règles :

On ne peut pas instancier une classe abstraite : Paiement("Sara") provoque une TypeError.
Une classe fille n’est concrète (instanciable) que si elle écrit toutes les méthodes abstraites.

Exemple simple

Un employé générique ne peut pas être payé

La classe abstraite impose une méthode salaire(). Chaque type d’employé doit l’écrire.

from abc import ABC, abstractmethod

class Employe(ABC):
    @abstractmethod
    def salaire(self):
        pass

class Vacataire(Employe):
    def __init__(self, heures):
        self.heures = heures
    def salaire(self):
        return self.heures * 120

print(Vacataire(20).salaire())   # 2400
Employe()                        # TypeError : classe abstraite

Ce qui se passe

Employe() est refusé : on ne crée pas un objet à partir d’un modèle incomplet.
Vacataire écrit salaire() : on peut créer des vacataires.

Ce qu’une classe abstraite peut contenir

Une classe abstraite n’est pas vide : elle peut avoir un constructeur, des attributs et des méthodes concrètes partagées par toutes les filles, comme recu() dans l’exemple.

Exemple simple

Du code commun et une méthode à compléter

Une classe abstraite n’est pas vide : elle peut contenir un constructeur et des méthodes normales.

class Forme(ABC):
    def __init__(self, nom):
        self.nom = nom                     # code commun
    def decrire(self):                     # méthode normale
        return f"{self.nom} d'aire {self.aire()}"
    @abstractmethod
    def aire(self): ...                    # à compléter

class Carre(Forme):
    def __init__(self, c):
        super().__init__("Carré")
        self.c = c
    def aire(self):
        return self.c ** 2

print(Carre(3).decrire())   # Carré d'aire 9

Ce qui se passe

decrire() est écrite une fois dans Forme et sert à toutes les formes.
Elle appelle aire(), que chaque forme définit.

Pourquoi c’est utile

Le contrat est clair : toute nouvelle classe de paiement doit savoir payer.
Les oublis sont détectés dès la création de l’objet, pas en production.
Le reste du programme travaille avec le type général Paiement, grâce au polymorphisme.

Exemple simple

Le mot « instrument »

On peut acheter un oud ou un violon, mais pas « un instrument » tout court : c'est une idée générale. Une classe abstraite, c'est pareil : elle décrit une famille, on ne crée que des objets concrets.

Exemple simple

Le cahier des charges

Le cahier des charges dit « le site doit permettre de payer » sans dire comment. Chaque prestataire réalise ce point à sa façon. La méthode abstraite est ce point du cahier des charges.

from abc import ABC, abstractmethod

class Paiement(ABC):
    @abstractmethod
    def payer(self, montant):
        ...

3Manipuler

Exécutez. Puis enlevez la méthode payer() de la classe Virement et relancez : Python refuse de créer l'objet, l'oubli est détecté immédiatement.

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

from abc import ABC, abstractmethod

class Paiement(ABC):                       # classe abstraite
    def __init__(self, client):
        self.client = client

@abstractmethod
    def payer(self, montant):              # méthode abstraite
        """Chaque moyen de paiement doit l'écrire."""

def recu(self, montant):               # méthode concrète, héritée
        return f"Reçu : {self.client} a payé {montant} DH ({type(self).__name__})"

class Carte(Paiement):
    def __init__(self, client, numero):
        super().__init__(client)
        self.numero = numero[-4:]

def payer(self, montant):
        print(f"Débit de {montant} DH sur la carte ****{self.numero}")

class Livraison(Paiement):
    def payer(self, montant):
        print(f"{montant} DH à régler en espèces au livreur")

class Virement(Paiement):
    def payer(self, montant):
        print(f"Virement de {montant} DH en attente")

paiements = [Carte("Sara", "4970123412345678"), Livraison("Amine"), Virement("Hind")]
for p in paiements:
    p.payer(250)
    print(p.recu(250))

try:
    Paiement("Personne")
except TypeError as e:
    print("Erreur :", e)

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 · La classe abstraite Employe

Écrivez une classe abstraite Employe(nom) avec une méthode abstraite salaire(). Écrivez deux classes concrètes : Permanent (salaire fixe) et Vacataire (taux horaire × heures).

Voir le corrigé

from abc import ABC, abstractmethod

class Employe(ABC):
    def __init__(self, nom):
        self.nom = nom
    @abstractmethod
    def salaire(self):
        ...

class Permanent(Employe):
    def __init__(self, nom, fixe):
        super().__init__(nom)
        self.fixe = fixe
    def salaire(self):
        return self.fixe

class Vacataire(Employe):
    def __init__(self, nom, taux, heures):
        super().__init__(nom)
        self.taux, self.heures = taux, heures
    def salaire(self):
        return self.taux * self.heures

for e in [Permanent("Nora", 9000), Vacataire("Yassine", 120, 40)]:
    print(e.nom, e.salaire())

Exercice 2 · Concret ou abstrait ?

Dans chaque liste, quelle classe devrait être abstraite ? (1) Forme, Cercle, Carre ; (2) Animal, Chat, Chien ; (3) Document, Facture, Devis.

Voir le corrigé

1. Forme   2. Animal   3. Document
Ce sont des catégories générales : on ne crée jamais
« une forme » ou « un document » sans préciser lequel.

Exercice 3 · Lire l'erreur

Que signifie le message « Can't instantiate abstract class Virement without an implementation for abstract method 'payer' » ?

Voir le corrigé

Python refuse de créer un objet Virement parce que la classe
n'a pas écrit la méthode payer(), déclarée abstraite dans Paiement.
Il faut ajouter def payer(self, montant): ... dans Virement.

L'abstraction : classes et méthodes abstraites

1Situer

2Comprendre

Classe abstraite et méthode abstraite

Ce qu’une classe abstraite peut contenir

Pourquoi c’est utile

Le mot « instrument »

Le cahier des charges

3Manipuler

4Pratiquer

Exercice 1 · La classe abstraite Employe

Exercice 2 · Concret ou abstrait ?

Exercice 3 · Lire l'erreur

5Vérifier