Pattern metodo template

Fa parte della sezione Programmazione orientata agli oggetti del percorso Python di Coddy. Lezione 52 di 64.

Il Pattern Template Method definisce lo scheletro di un algoritmo in una classe base, consentendo alle sottoclassi di sovrascrivere passaggi specifici senza modificare la struttura dell’algoritmo.

Ecco una classe base con un metodo template:

class DataProcessor:
    def process(self):
        """Metodo template che definisce la struttura dell'algoritmo"""
        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...")

Il metodo modello process() definisce i passaggi dell’algoritmo, mentre process_data() è lasciato alle sottoclassi da implementare.

Crea classi concrete che implementano il metodo astratto:

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

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

Ogni classe concreta fornisce la propria implementazione del passaggio richiesto.

Usa il metodo template:

csv_processor = CSVProcessor()
csv_processor.process()

print()  # Riga vuota

json_processor = JSONProcessor()
json_processor.process()

Crea un altro esempio con un modello di gioco:

class Game:
    def play(self):
        """Metodo template per giocare a un gioco"""
        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()

Output:

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

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

Punto chiave: il pattern Template Method definisce una struttura comune dell'algoritmo nella classe padre, lasciando alle sottoclassi la possibilità di personalizzare passaggi specifici. La classe padre controlla il flusso complessivo, mentre le sottoclassi forniscono le implementazioni specifiche. Questo assicura una struttura coerente, consentendo al contempo flessibilità nei singoli passaggi.

Sfida

Medio

Implementa il pattern Template Method in template.py. La classe astratta Report possiede il metodo template generate(), che esegue sempre gli stessi tre passaggi nello stesso ordine: header(), body(), footer().

header() è condiviso da ogni report e stampa === Report ===.
body() è astratto: ogni sottoclasse stampa il proprio contenuto.
footer() è un hook con un valore predefinito, === End ===, che una sottoclasse può sovrascrivere.

Scrivi quindi i due report concreti:

SalesReport(total) memorizza il totale in self._total e stampa Total sales: {total} nel proprio corpo.
InventoryReport(items) memorizza la lista in self._items, stampa Item: {item} per ogni elemento nel proprio corpo e sovrascrive il footer per stampare === {count} items ===.

driver.py è bloccato: crea i report e chiama generate() su di essi. Solo i passaggi differiscono tra le sottoclassi; l'ordine dei passaggi è definito una sola volta nella classe base.

Provalo tu

from template import SalesReport, InventoryReport

# Gestore dei casi di test (non modificare)
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()