Le patron de conception State en Python
Dans cette leçon, vous allez utiliser le patron State pour changer le comportement d'un objet quand son état interne change.
Introduction
Le problème
Un lecteur multimédia se comporte différemment quand il lit, est en pause ou arrêté. Écrire une grosse méthode pleine de tests if state == ... oblige chaque nouvel état à toucher chaque méthode. Le pattern State donne à chaque état son propre objet.
Imaginez-le ainsi
Le patron State ressemble au bouton lecture/pause unique d'un lecteur de musique. Le même appui fait des choses différentes selon ce que fait le lecteur à ce moment-là : il met en pause pendant la lecture, et relance la lecture quand il est en pause. Changer d'état change ce que fait le bouton, sans reconstruire le lecteur.
Paused(), Playing()⏯️ Les deux choses que le lecteur peut être en train de faireself.state💡 Ce qu'il fait en ce momentplayer.set_state(Playing())🔁 Passer à l'autre étatself.state.action()👆 Le bouton demande à l'état actuel quoi faireLe pattern State permet à un objet de changer de comportement quand son état interne change, en déléguant à un objet séparé pour chaque état.
Points clés
PlayingetPausedont toutes deux une méthodeaction().Playercommence dans l'étatPaused.set_stateremplace l'objet d'état actuel.Player.action()délègue àself.state.action(), donc le résultat change avec l'état.
Quand l’utiliser ?
- Les objets avec des modes clairs : lecteurs multimédias, commandes, connexions, personnages de jeu.
- Remplacer de grandes chaînes
if/elifsur un champ de statut. - Les déroulements où chaque étape autorise des actions différentes.
Quand s'en passer
- Deux états simples avec une petite différence : un drapeau booléen suffit.
- Les états qui partagent presque tout leur comportement : des classes séparées dupliquent le code.
Code d’exemple
class Playing:
# State: delegate behavior to the current state object.
def action(self): return "Playing"
class Paused:
def action(self): return "Paused"
class Player:
def __init__(self): self.state = Paused()
def set_state(self, state): self.state = state
def action(self):
# Behavior comes from the current state object.
return self.state.action()
player = Player()
player.set_state(Playing())
print(player.action())
player.set_state(Paused())
print(player.action())
Résultat de l’exécution
Playing
Paused
Explication du code
La méthode action() de Player ne fait pas le travail elle-même : elle le confie à l'objet d'état courant. Après set_state(Playing()), le résultat est Playing. Après le passage à set_state(Paused()), le même appel action() donne Paused. Pour ajouter un état, il suffit de créer une nouvelle classe d'état.
Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.
Exercices d’approfondissement
Essayez de modifier le code en suivant les pistes ci-dessous. Changer le code et observer le résultat vous fera bien mieux comprendre la leçon que la simple lecture.
- Remplacez le domaine de l’exemple tout en conservant la structure du pattern.
- Comparez le pattern à une implémentation plus simple et expliquez les compromis.
- Écrivez des tests pour chaque participant avant d’ajouter une autre implémentation.
Erreurs fréquentes
Tester l'état avec des if
Chaque nouvel état oblige à modifier chaque méthode.
def action(self):
if self.state == "playing":
return "Playing"
return "Paused"
def action(self):
return self.state.action()
Leçon terminée ?
Marquez-la comme apprise pour suivre votre progression.
S'entraîner avec un défi
Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.
Tous les défis