Patrons de conception Python

Le patron de conception Decorator en Python

Dans cette leçon, vous allez utiliser le patron Decorator pour ajouter des fonctionnalités à un objet sans modifier sa classe.

  • Avancé
  • 3 min de lecture
  • 1 exemple exécutable

Introduction

Le problème

Vous voulez ajouter un comportement à un objet, comme de la journalisation, de la mise en forme ou du cache, sans modifier sa classe et sans créer une sous-classe pour chaque combinaison d'extras.

Imaginez-le ainsi

Le pattern Decorator, c'est comme emballer un cadeau. Le cadeau reste le même ; chaque couche d'emballage ajoute quelque chose, comme du papier, puis un ruban, puis une carte. Vous pouvez ajouter les couches dans n'importe quel ordre, et le résultat reste un cadeau qu'on remet de la même façon.

De l'emballage cadeau au code
Message()🎁 Le cadeau d'origine
Uppercase(...)🧻 Une couche qui change son apparence
Logger(...)🎀 Une autre couche par-dessus
.render()🤲 Remis de la même façon : LOG: HELLO
Chaque enveloppe offre la même méthode et ajoute son propre comportement.
En une phrase

Le pattern Decorator enveloppe un objet dans un autre objet de même interface, qui appelle l'objet enveloppé et ajoute un comportement avant ou après.

Points clés

  1. Message.render() renvoie "hello".
  2. Uppercase contient l'objet enveloppé et renvoie son résultat en majuscules.
  3. Logger ajoute "LOG: " devant le résultat de l'objet enveloppé.
  4. Logger(Uppercase(Message())).render() empile les deux enveloppes, ce qui donne "LOG: HELLO".

Quand l’utiliser ?

  • Ajouter journalisation, cache, validation ou mise en forme autour d'objets existants.
  • Combiner des extras facultatifs sans sous-classe pour chaque combinaison.
  • Comprendre la syntaxe @decorator de Python, qui applique la même idée aux fonctions.

Quand s'en passer

  • Un seul comportement fixe en plus est nécessaire : modifiez la classe ou ajoutez une méthode.
  • Beaucoup de couches qui dépendent de leur ordre mutuel : la pile devient difficile à comprendre.

Code d’exemple

Exécuter le code →
main.py
class Message:
    # Decorator: wrap an object to add behavior dynamically.
    def render(self): return "hello"


class Uppercase:
    def __init__(self, wrapped): self.wrapped = wrapped
    def render(self): return self.wrapped.render().upper()


class Logger:
    def __init__(self, wrapped): self.wrapped = wrapped

    def render(self):
        # Add behavior while preserving the render interface.
        return "LOG: " + self.wrapped.render()


print(Logger(Uppercase(Message())).render())
Obtenir un bouton Run pour cet exemple

Résultat de l’exécution

LOG: HELLO

Explication du code

Uppercase enveloppe l'objet Message et passe le résultat en majuscules, puis Logger enveloppe Uppercase et ajoute le préfixe LOG:. Les trois classes ont la méthode render(), elles peuvent donc s'envelopper mutuellement dans n'importe quel ordre. Le résultat final est LOG: HELLO.

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.

  1. Remplacez le domaine de l’exemple tout en conservant la structure du pattern.
  2. Comparez le pattern à une implémentation plus simple et expliquez les compromis.
  3. Écrivez des tests pour chaque participant avant d’ajouter une autre implémentation.
Exécuter dans le compilateur Python →

Erreurs fréquentes

Casser l'interface commune

Une enveloppe avec un autre nom de méthode ne peut pas être réenveloppée ni remplacer l'original.

Problème
class Uppercase:
    def show(self): ...
Correction
class Uppercase:
    def render(self): ...

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