Cinq principes de conception qui rendent le code facile à étendre sans le casser.
⏱️ Durée : environ 90 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Maître des cinq principes
🎬 L'histoire
HashBox ajoute un nouveau moyen de paiement toutes les deux semaines. À chaque fois, Kodi ouvre la fonction payer, ajoute un elif, et casse parfois les paiements existants.
« Ton code est ouvert à la casse et fermé à l'extension, plaisante Sam. Il faut l'inverser. SOLID, c'est cinq règles pour y parvenir. »
Tu apprends les cinq principes SOLID avec des exemples concrets en Python.
🎯 Ta mission
À la fin, je serai capable de :
- énoncer les cinq principes S-O-L-I-D
- reconnaître la violation de chacun dans un code
- refactorer un code vers le principe ouvert/fermé
- utiliser des
Protocolpour l'inversion de dépendances - savoir quand ne pas appliquer SOLID à la lettre
🧩 Défi d'échauffement (5 XP)
Un restaurant propose aujourd'hui trois modes de paiement (carte, espèces, chèque-repas). Le manager veut en ajouter un quatrième tous les mois. Pour chaque ajout, faut-il réécrire le fonctionnement de la caisse ou simplement brancher un nouveau module de paiement ? Dessine l'idée d'une caisse qui accepte n'importe quel module respectant une même « prise ».
💡 Le concept
S — Responsabilité unique (Single Responsibility)
Une classe doit avoir une seule raison de changer.
Reprise de la mission précédente : une classe qui calcule, sauvegarde et formate a trois raisons de changer.
O — Ouvert/fermé (Open/Closed)
Le code doit être ouvert à l'extension, fermé à la modification.
Ajouter un comportement = ajouter du code nouveau, pas modifier du code qui marche.
# Violation : chaque nouveau moyen de paiement oblige à modifier cette fonction
def payer(moyen, montant):
if moyen == "carte":
...
elif moyen == "especes":
...
L — Substitution de Liskov (Liskov Substitution)
Un sous-type doit pouvoir remplacer son type de base sans casser le programme.
Exemple de violation : Carre hérite de Rectangle, mais modifier la largeur d'un Carre modifie aussi sa hauteur, ce qui surprend le code écrit pour des rectangles. Un sous-type ne doit pas renforcer les préconditions ni affaiblir les garanties.
I — Ségrégation des interfaces (Interface Segregation)
Mieux vaut plusieurs petites interfaces qu'une grosse.
Une interface Appareil avec imprimer, scanner, faxer oblige une imprimante simple à implémenter scanner (qu'elle ne sait pas faire).
D — Inversion des dépendances (Dependency Inversion)
Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau ; tous deux dépendent d'abstractions.
Le service de paiement dépend d'une interface Paiement, pas de Stripe ou PayPal directement.
Un résumé
| Lettre | Question à se poser |
|---|---|
| S | Combien de raisons de changer ? |
| O | Puis-je ajouter un cas sans modifier l'existant ? |
| L | Puis-je substituer un sous-type sans surprise ? |
| I | Les clients dépendent-ils de méthodes qu'ils n'utilisent pas ? |
| D | Mon cœur dépend-il de détails (base, API) ou d'abstractions ? |
Les Protocol de Python
Python permet de décrire une interface par ses méthodes (typage structurel) :
from typing import Protocol
class Paiement(Protocol):
def payer(self, montant: float) -> str: ...
Toute classe qui possède une méthode payer(montant) satisfait l'interface, sans héritage.
Attention à l'excès
SOLID sert à gérer le changement. Appliqué partout, par réflexe, il produit des dizaines de petites classes inutiles. On applique un principe quand la douleur apparaît (un deuxième moyen de paiement), pas avant (YAGNI).
🔍 Exemple pas à pas
Problème : passer d'une chaîne de elif à une conception ouverte/fermée.
Avant :
def payer_v1(moyen, montant):
if moyen == "carte":
return f"carte: {montant:.2f} EUR (frais 1,5 %: {montant * 0.015:.2f})"
elif moyen == "especes":
return f"especes: {montant:.2f} EUR"
elif moyen == "cheque_repas":
return f"cheque_repas: {min(montant, 25):.2f} EUR (plafond 25)"
raise ValueError("moyen inconnu")
Après : chaque moyen de paiement est une classe qui respecte une interface ; le service ne change jamais.
from typing import Protocol
class MoyenPaiement(Protocol):
nom: str
def payer(self, montant: float) -> str: ...
class Carte:
nom = "carte"
def payer(self, montant):
return f"carte: {montant:.2f} EUR (frais 1,5 %: {montant * 0.015:.2f})"
class Especes:
nom = "especes"
def payer(self, montant):
return f"especes: {montant:.2f} EUR"
class ChequeRepas:
nom = "cheque_repas"
plafond = 25
def payer(self, montant):
return f"cheque_repas: {min(montant, self.plafond):.2f} EUR (plafond {self.plafond})"
class Caisse:
"""Dépend de l'abstraction MoyenPaiement (D) ; ouverte à l'ajout de moyens (O)."""
():
.moyens = {m.nom: m m moyens}
():
nom .moyens:
ValueError()
.moyens[nom].payer(montant)
caisse = Caisse([Carte(), Especes(), ChequeRepas()])
moyen, montant [(, ), (, ), (, )]:
caisse.payer(moyen, montant) == payer_v1(moyen, montant)
:
nom =
():
caisse.moyens[] = Virement()
(caisse.payer(, ))
Ce qu'on a gagné : ajouter Virement n'a modifié ni Caisse, ni les autres moyens, ni leurs tests. C'est l'ouverture/fermeture.
Une violation de Liskov, pour comprendre :
class Rectangle:
def __init__(self, l, h):
self.l, self.h = l, h
def definir_largeur(self, l):
self.l = l
def aire(self):
return self.l * self.h
class Carre(Rectangle):
def definir_largeur(self, l):
self.l = self.h = l # surprend le code qui attend un rectangle
def agrandir_largeur(r):
r.definir_largeur(10)
return r.aire() # on attend 10 * h
print(agrandir_largeur(Rectangle(2, 5))) # 50
print(agrandir_largeur(Carre(2, 2))) # 100 : le comportement attendu n'est plus respecté
✍️ À toi, avec aide (10 XP)
Identifie le principe SOLID violé dans chaque cas et propose la correction :
- Une classe
Utilisateurcontientvalider_email,sauvegarder_en_base,envoyer_mail_bienvenueetafficher_en_html. - Pour chaque nouveau format d'export (CSV, JSON, PDF), on ajoute un
elifdansexporter(format, donnees). - Une interface
Oiseauimposevoler(), etPingouinimplémentevoler()en levant une exception. - Un
ServiceCommandecrée lui-mêmeConnexionMySQL()dans son constructeur. - Une interface
Travailleurimposetravailler()etmanger(), et unRobotdoit implémentermanger()pour rien.
💡 Indice 1
Pense aux lettres dans l'ordre : S, O, L, D, I.
💡 Indice 2
Le 3 : un sous-type qui ne sait pas faire ce que promet son type de base.
💡 Indice 3
Le 5 : une interface trop large impose des méthodes inutiles.
✅ Réponse
- S (responsabilité unique) → séparer validation, persistance, notification, présentation.
- O (ouvert/fermé) → un
Exporteurpar format derrière une interface commune, choisi dans un dictionnaire. - L (Liskov) → un
Pingouinn'est pas unOiseauVolant: séparerOiseauetOiseauVolant. - D (inversion des dépendances) → injecter un
Depot(interface), pas une classe concrète. - I (ségrégation des interfaces) →
TravailleuretMangeurséparés ;Robotn'implémente queTravailleur.
🚀 À toi, en solo (20 XP)
Exports extensibles. Écris exporter(donnees, format) d'abord avec des if/elif pour CSV, JSON et texte brut. Puis refactore-la :
- un
ProtocolExporteuravecexporter(donnees) -> str; - trois classes qui le satisfont ;
- un
ServiceExportqui reçoit les exporteurs par injection ; - ajoute un format
markdownsans modifier le service ni les exporteurs existants ; - teste que l'ancien comportement est inchangé.
✅ Pistes de correction
import json
from typing import Protocol
def exporter_v1(donnees, format):
if format == "csv":
return "\n".join(",".join(str(v) for v in ligne.values()) for ligne in donnees)
if format == "json":
return json.dumps(donnees, sort_keys=True)
if format == "texte":
return "\n".join(" | ".join(f"{k}={v}" for k, v in ligne.items()) for ligne in donnees)
raise ValueError(format)
class Exporteur(Protocol):
format: str
def exporter(self, donnees) -> str: ...
class :
=
():
.join(.join((v) v ligne.values()) ligne donnees)
:
=
():
json.dumps(donnees, sort_keys=)
:
=
():
.join(.join( k, v ligne.items()) ligne donnees)
:
():
._par_format = {e.: e e exporteurs}
():
._par_format:
ValueError()
._par_format[].exporter(donnees)
donnees = [{: , : }, {: , : }]
service = ServiceExport([CSV(), JSON(), Texte()])
f (, , ):
service.exporter(donnees, f) == exporter_v1(donnees, f)
:
=
():
cles = (donnees[])
lignes = [ + .join(cles) + , + * (cles)]
lignes += [ + .join((l[c]) c cles) + l donnees]
.join(lignes)
service._par_format[] = Markdown()
(service.exporter(donnees, ))
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Appliquer SOLID avant d'en avoir besoin | Dizaines de petites classes inutiles | Attendre le deuxième cas, puis généraliser |
| Héritage pour réutiliser du code | Violations de Liskov | Préférer la composition |
| Interfaces énormes | Classes qui implémentent du vide | Petites interfaces ciblées |
| Abstraction qui fuit les détails | L'interface expose le fournisseur | Concevoir l'interface selon le besoin du client |
🐉 Mini-boss (40 XP)
Système de notifications SOLID. HashBox envoie des notifications : e-mail, SMS, notification mobile. Règles : un utilisateur a des préférences de canaux ; certaines notifications sont urgentes (tous les canaux) ; chaque canal peut échouer et on doit réessayer ou basculer.
- Écris d'abord une version naïve (une fonction avec
if/elif). - Refactore en respectant S, O, L, I, D : interface
Canal, implémentations,PolitiqueEnvoi(choix des canaux),Servicequi reçoit tout par injection. - Ajoute un canal « Slack » sans modifier le service.
- Écris les tests avec de faux canaux (succès, échec, échec puis succès).
- Explique en 6 lignes quel principe justifie chaque choix.
✅ Pistes de correction
Un bon travail : Canal(Protocol) avec envoyer(utilisateur, message) -> bool ; PolitiqueEnvoi.canaux_pour(utilisateur, urgent) (responsabilité unique : choisir) ; Service.notifier parcourt les canaux, gère le réessai et le basculement (responsabilité : orchestration) ; les canaux concrets sont injectés. Les tests utilisent FauxCanal(reussit=True/False/[False, True]) et vérifient qu'une urgence passe par tous les canaux, qu'un échec bascule sur le suivant et que Slack s'ajoute par une simple instance. L'explication associe S à PolitiqueEnvoi, O à l'ajout de Slack, L à la substituabilité des canaux, I à la petite interface Canal, D à l'injection.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Le principe ouvert/fermé dit :
- A. ouvert à la modification, fermé à l'extension
- B. ouvert à l'extension, fermé à la modification
- C. tout est ouvert
2. Liskov est violé quand :
- A. une classe a deux méthodes
- B. on utilise des interfaces
- C. un sous-type ne peut pas remplacer son type de base sans surprise
3. Inverser les dépendances, c'est :
- A. dépendre d'abstractions plutôt que de détails
- B. supprimer les dépendances
- C. tout mettre dans une classe
4. 🔁 Révision mission 02 : Une forte cohésion signifie :
- A. le module dépend de beaucoup d'autres
- B. le module fait une chose bien définie
- C. le module est très long
5. 🔁 Révision mission 02 : L'injection de dépendances consiste à :
- A. créer les dépendances dans la classe
- B. supprimer les dépendances
- C. fournir les dépendances de l'extérieur
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel principe SOLID te semble le plus naturel, et lequel le plus difficile à appliquer ?
- Dans quel cas appliquer SOLID serait-il de la sur-ingénierie ?
🎒 À retenir
- S : une seule raison de changer.
- O : étendre sans modifier.
- L : un sous-type remplace son type de base.
- I : petites interfaces ciblées.
- D : dépendre d'abstractions ; appliquer quand la douleur apparaît.
flowchart LR
T(["Les principes SOLID"])
T --> R1["1. S : une seule raison de changer."]
T --> R2["2. O : étendre sans modifier."]
T --> R3["3. L : un sous-type remplace son type de base."]
T --> R4["4. I : petites interfaces ciblées."]
T --> R5["5. D : dépendre d'abstractions ; appliquer quand la douleur apparaît."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Maître des cinq principes
← Mission 02 — Cohésion et couplage · Mission 04 — Clean Code : écrire pour être lu →
HEF-080 — Génie logiciel

