Patron Méthode Template

Fait partie de la section Programmation orientée objet du Journey Python de Coddy. Leçon 52 sur 64.

Le patron de méthode modèle définit la structure d’un algorithme dans une classe de base, permettant aux sous-classes de redéfinir certaines étapes sans modifier la structure de l’algorithme.

Voici une classe de base avec une méthode modèle :

class DataProcessor:
    def process(self):
        """Méthode template définissant la structure de l'algorithme"""
        self.read_data()
        self.process_data()
        self.save_data()
    
    def read_data(self):
        print("Reading data...")
    
    def process_data(self):
        raise NotImplementedError("Subclasses must implement this")
    
    def save_data(self):
        print("Saving data...")

La méthode modèle process() définit les étapes de l’algorithme, tandis que process_data() est laissée aux sous-classes pour être implémentée.

Créez des classes concrètes qui implémentent la méthode abstraite :

class CSVProcessor(DataProcessor):
    def process_data(self):
        print("Processing CSV data")

class JSONProcessor(DataProcessor):
    def process_data(self):
        print("Processing JSON data")

Chaque classe concrète fournit sa propre implémentation de l’étape requise.

Utilisez la méthode modèle :

csv_processor = CSVProcessor()
csv_processor.process()

print()  # Ligne vide

json_processor = JSONProcessor()
json_processor.process()

Créez un autre exemple avec un modèle de jeu :

class Game:
    def play(self):
        """Méthode template pour jouer à un jeu"""
        self.start_game()
        self.play_game()
        self.end_game()
    
    def start_game(self):
        print("Game started!")
    
    def play_game(self):
        raise NotImplementedError("Define the game rules")
    
    def end_game(self):
        print("Game ended!")

class Chess(Game):
    def play_game(self):
        print("Playing chess - thinking strategically...")

class Soccer(Game):
    def play_game(self):
        print("Playing soccer - running and kicking...")

chess = Chess()
chess.play()

Sortie :

Reading data...
Processing CSV data
Saving data...

Reading data...
Processing JSON data
Saving data...
Game started!
Playing chess - thinking strategically...
Game ended!

Point clé : le patron de méthode modèle définit une structure d’algorithme commune dans la classe parente tout en permettant aux sous-classes de personnaliser certaines étapes. La classe parente contrôle le flux global, mais les sous-classes fournissent les implémentations spécifiques. Cela garantit une structure cohérente tout en permettant une certaine flexibilité dans les différentes étapes.

Défi

Moyen

Implémentez le patron Template Method dans template.py. La classe abstraite Report possède la méthode modèle generate(), qui exécute toujours les mêmes trois étapes dans le même ordre : header(), body(), footer().

header() est partagé par tous les rapports et affiche === Report ===.
body() est abstraite : chaque sous-classe affiche son propre contenu.
footer() est un hook dont la valeur par défaut est === End === et qu’une sous-classe peut redéfinir.

Écrivez ensuite les deux rapports concrets :

SalesReport(total) stocke le total dans self._total et affiche Total sales: {total} dans son corps.
InventoryReport(items) stocke la liste dans self._items, affiche Item: {item} pour chaque élément dans son corps et redéfinit le pied de page pour afficher === {count} items ===.

driver.py est verrouillé : il construit les rapports et appelle generate() sur ceux-ci. Seules les étapes diffèrent entre les sous-classes ; l’ordre des étapes est défini une seule fois dans la classe de base.

Essayez vous-même

from template import SalesReport, InventoryReport

# Gestionnaire de cas de test (ne pas modifier)
test_case = input()

if test_case == "sales_test":
    SalesReport(1500).generate()
elif test_case == "inventory_test":
    InventoryReport(["Laptop", "Mouse"]).generate()
elif test_case == "both_test":
    for report in [SalesReport(200), InventoryReport(["Pen"])]:
        report.generate()