Patrón Template Method

Parte de la sección Programación orientada a objetos del Journey de Python de Coddy. Lección 52 de 64.

El patrón Método de plantilla define el esqueleto de un algoritmo en una clase base y permite que las subclases sobrescriban pasos específicos sin cambiar la estructura del algoritmo.

Aquí tienes una clase base con un método plantilla:

class DataProcessor:
    def process(self):
        """Método plantilla que define la estructura del 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...")

El método plantilla process() define los pasos del algoritmo, mientras que las subclases deben implementar process_data().

Crea clases concretas que implementen el método abstracto:

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

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

Cada clase concreta proporciona su propia implementación del paso requerido.

Usa el método de plantilla:

csv_processor = CSVProcessor()
csv_processor.process()

print()  # Línea en blanco

json_processor = JSONProcessor()
json_processor.process()

Crea otro ejemplo con una plantilla de juego:

class Game:
    def play(self):
        """Método plantilla para jugar una partida"""
        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()

Salida:

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

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

Punto clave: El patrón Método Plantilla define una estructura de algoritmo común en la clase padre y permite que las subclases personalicen pasos específicos. La clase padre controla el flujo general, pero las subclases proporcionan las implementaciones específicas. Esto garantiza una estructura coherente y permite flexibilidad en los pasos individuales.

Desafío

Intermedio

Implementa el patrón Template Method en template.py. La clase abstracta Report contiene el método plantilla generate(), que siempre ejecuta los mismos tres pasos en el mismo orden: header(), body(), footer().

header() es compartido por todos los informes e imprime === Report ===.
body() es abstracto: cada subclase imprime su propio contenido.
footer() es un método gancho con un valor predeterminado, === End ===, que una subclase puede sobrescribir.

Después, escribe los dos informes concretos:

SalesReport(total) guarda el total en self._total e imprime Total sales: {total} en su cuerpo.
InventoryReport(items) guarda la lista en self._items, imprime Item: {item} por cada elemento en su cuerpo y sobrescribe el pie para imprimir === {count} items ===.

driver.py está bloqueado: crea informes y llama a generate() en ellos. Solo cambian los pasos entre las subclases; el orden de los pasos se define una sola vez en la clase base.

Pruébalo tú mismo

from template import SalesReport, InventoryReport

# Gestor de casos de prueba (no modificar)
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()