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 Plantilla define el esqueleto de un algoritmo en una clase base, lo que permite que las subclases redefinan pasos específicos sin cambiar la estructura del algoritmo.

Aquí tienes una clase base con un método de 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 process_data() queda para que las subclases lo implementen.

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 vacía

json_processor = JSONProcessor()
json_processor.process()

Crea otro ejemplo con una plantilla de juego:

class Game:
    def play(self):
        """Método plantilla para jugar un juego"""
        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 de método plantilla define una estructura de algoritmo común en la clase principal, al tiempo que permite que las subclases personalicen pasos específicos. La clase principal controla el flujo general, pero las subclases proporcionan las implementaciones específicas. Esto garantiza una estructura coherente y, al mismo tiempo, permite flexibilidad en los pasos individuales.

Desafío

Intermedio

Implementa el patrón Template Method en template.py. La clase abstracta Report posee 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 hook con un valor predeterminado, === End ===, que una subclase puede sobrescribir.

Después escribe los dos informes concretos:

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

driver.py está bloqueado: construye informes y llama a generate() en ellos. Solo los pasos difieren 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

# Manejador de casos de prueba (no cambiar)
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()