Patron Méthode Template

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 52 sur 64.

Le patron de méthode (Template Method Pattern) définit le squelette d'un algorithme dans une classe de base, permettant aux sous-classes de redéfinir certaines étapes spécifiques sans modifier la structure de l'algorithme.

Voici une classe de base avec une méthode template :

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 template process() définit les étapes de l'algorithme, tandis que process_data() est laissée à l'implémentation des sous-classes.

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 le patron de méthode :

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):
        """Template method for playing a game"""
        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 conception Template Method définit une structure d'algorithme commune dans la classe parente tout en laissant les sous-classes personnaliser des étapes spécifiques. 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 étapes individuelles.

Défi

Moyen

Implémentez template.py et driver.py avec une encapsulation et des méthodes appropriées. Suivez les commentaires TODO pour un guidage étape par étape.

Aide-mémoire

Le patron de conception Template Method définit le squelette d'un algorithme dans une classe de base, permettant aux sous-classes de redéfinir certaines étapes sans modifier la structure de l'algorithme.

Créez une classe de base avec une méthode template :

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...")

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")

Utilisez la méthode template :

csv_processor = CSVProcessor()
csv_processor.process()

json_processor = JSONProcessor()
json_processor.process()

Le patron de conception Template Method définit une structure d'algorithme commune dans la classe parente tout en laissant les sous-classes personnaliser des étapes spécifiques. La classe parente contrôle le flux global, mais les sous-classes fournissent les implémentations spécifiques.

Essayez vous-même

from template import Template

# Gestionnaire de cas de test
test_case = input()

if test_case == "basic_test":
    # TODO: Créer un objet Template avec le nom "Test Name"
    # TODO: Appeler la méthode display_info() sur l'objet
    pass
elif test_case == "validation_test":
    # TODO: Créer un objet Template avec le nom "Validation Test"
    # TODO: Afficher le nom en utilisant la propriété name au format : "Name: {obj.name}"
    pass