Patrons de conception Python

Le patron de conception Strategy en Python

Dans cette leçon, vous allez utiliser le patron Strategy pour choisir et changer d'algorithme pendant l'exécution du programme.

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

Introduction

Le problème

Le prix ne se calcule pas forcément de la même façon pour les clients ordinaires, pour les membres ou pendant les soldes. Si toutes les règles sont dans une seule fonction, avec une longue chaîne de if / elif, cette fonction grossit à chaque nouvelle règle. Le pattern Strategy permet de brancher la règle dont vous avez besoin.

Imaginez-le ainsi

Le pattern Strategy, c'est comme choisir un itinéraire dans une appli de navigation : le plus rapide, le plus court ou sans péage. Le trajet reste le même. Vous choisissez la stratégie d'itinéraire qui vous convient, et l'appli la suit sans changer sa façon de vous guider.

Du choix d'itinéraire au code
regular_discount, member_discount🗺️ Les itinéraires disponibles
Checkout(member_discount)📍 En choisir un au départ
self.discount_strategy(amount)🚗 Suivre l'itinéraire choisi
12.00💳 Le prix membre pour 15
L'algorithme se branche de l'extérieur, il n'est pas codé en dur.
En une phrase

Le pattern Strategy place chaque variante d'un algorithme derrière la même interface, ici une fonction avec les mêmes paramètres, et laisse l'appelant choisir laquelle utiliser.

Points clés

  1. regular_discount et member_discount prennent un total et renvoient le montant à payer.
  2. Checkout reçoit l'une d'elles comme discount_strategy.
  3. total(amount) appelle la stratégie stockée sans savoir laquelle c'est.
  4. member_discount accorde 20 % de remise, donc 15 devient 12.00.

Quand l’utiliser ?

  • Les règles interchangeables : tarification, tri, validation, formats de fichiers.
  • Remplacer de longues chaînes if / elif qui choisissent entre des algorithmes.
  • Tester avec des stratégies factices toutes simples.

Quand s'en passer

  • Il n'y a qu'une ou deux règles simples, qui changent rarement : un if est plus clair.
  • Les stratégies qui demandent des entrées très différentes : leur imposer une seule interface donne un résultat bancal.

Code d’exemple

Exécuter le code →
main.py
def regular_discount(total): return total
def member_discount(total): return total * 0.8


class Checkout:
    # Strategy: inject the algorithm that is allowed to vary.
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def total(self, amount):
        # Delegate the varying algorithm to the strategy.
        return self.discount_strategy(amount)


checkout = Checkout(member_discount)
print(f"{checkout.total(15):.2f}")
Obtenir un bouton Run pour cet exemple

Résultat de l’exécution

12.00

Explication du code

La classe Checkout reçoit la fonction de remise discount_strategy à sa création et lui confie tout le calcul dans la méthode total(). Avec la stratégie member_discount, une commande de 15 revient à 12.00. Pour changer de calcul, il suffit de passer une autre fonction, sans modifier la classe Checkout.

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

Appeler la stratégie au moment de la passer

Checkout(member_discount()) passe le résultat, pas la fonction.

Problème
checkout = Checkout(member_discount())  # TypeError
Correction
checkout = Checkout(member_discount)

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