Pattern decoratore

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

Il pattern Decorator aggiunge nuove funzionalità agli oggetti in modo dinamico senza modificarne la struttura. Avvolge gli oggetti per estenderne il comportamento.

Ecco un semplice esempio di caffè:

class Coffee:
    def cost(self):
        return 5
    
    def description(self):
        return "Simple coffee"

Crea decoratori che aggiungono funzionalità al caffè:

class MilkDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 2
    
    def description(self):
        return self.coffee.description() + " + Milk"

class SugarDecorator:
    def __init__(self, coffee):
        self.coffee = coffee
    
    def cost(self):
        return self.coffee.cost() + 1
    
    def description(self):
        return self.coffee.description() + " + Sugar"

Ogni decoratore avvolge un altro oggetto e aggiunge le proprie funzionalità.

Usa i decoratori per preparare un caffè personalizzato:

# Inizia con un caffè semplice
my_coffee = Coffee()
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# Aggiungi il latte
my_coffee = MilkDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

# Aggiungi lo zucchero
my_coffee = SugarDecorator(my_coffee)
print(f"{my_coffee.description()}: ${my_coffee.cost()}")

Crea un altro esempio con la formattazione del testo:

class Text:
    def __init__(self, content):
        self.content = content
    
    def render(self):
        return self.content

class BoldDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<b>{self.text.render()}</b>"

class ItalicDecorator:
    def __init__(self, text):
        self.text = text
    
    def render(self):
        return f"<i>{self.text.render()}</i>"

# Crea il testo formattato passo dopo passo
message = Text("Hello World")
message = BoldDecorator(message)
message = ItalicDecorator(message)

print(message.render())

Output:

Simple coffee: $5
Simple coffee + Milk: $7
Simple coffee + Milk + Sugar: $8
<i><b>Hello World</b></i>

Punto chiave: il pattern Decorator avvolge gli oggetti per aggiungere nuovi comportamenti senza modificare l’oggetto originale. Ogni decorator mantiene un riferimento all’oggetto avvolto e aggiunge le proprie funzionalità. Questo ti consente di combinare più decorator per ottenere combinazioni di funzionalità flessibili senza creare molte sottoclassi.

Sfida

Medio

In questa sfida implementerai il pattern di progettazione Decorator per creare un sistema flessibile per ordinare caffè in una caffetteria. Il pattern Decorator consente di aggiungere dinamicamente comportamenti a singoli oggetti, senza influire sul comportamento degli altri oggetti della stessa classe.

Stai realizzando un sistema per una caffetteria che deve:

Offrire vari tipi di bevande (Espresso, Dark Roast, House Blend, Decaf)
Consentire ai clienti di aggiungere condimenti (Milk, Mocha, Soy, Whipped Cream) alle loro bevande
Calcolare il costo delle bevande con i condimenti aggiunti

Completa la classe astratta Beverage e le sue implementazioni concrete in beverage.py
Implementa la classe astratta CondimentDecorator e i decorator concreti in condiment_decorator.py
Implementa gli scenari di test in driver.py per verificare la tua implementazione

Provalo tu

# Importa tutte le classi necessarie
from beverage import Espresso, HouseBlend, DarkRoast, Decaf
from condiment_decorator import Milk, Mocha, Soy, Whip

# Gestore completo dei casi di test
test_case = input()

if test_case == "basic_beverage_test":
    # Verifica le funzionalità di base delle bevande
    espresso = Espresso()
    print(f"Description: {espresso.get_description()}")
    print(f"Cost: ${espresso.cost():.2f}")

elif test_case == "all_beverages_test":
    # Verifica tutti i tipi di bevande
    beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    for beverage in beverages:
        print(f"{beverage.get_description()}: ${beverage.cost():.2f}")

elif test_case == "single_condiment_test":
    # Verifica l'aggiunta di un solo ingrediente
    espresso = Espresso()
    espresso_with_milk = Milk(espresso)
    print(f"Description: {espresso_with_milk.get_description()}")
    print(f"Cost: ${espresso_with_milk.cost():.2f}")

elif test_case == "multiple_condiments_test":
    # Verifica l'aggiunta di più ingredienti
    house_blend = HouseBlend()
    decorated_coffee = Mocha(Soy(Whip(house_blend)))
    print(f"Description: {decorated_coffee.get_description()}")
    print(f"Cost: ${decorated_coffee.cost():.2f}")

elif test_case == "all_condiments_test":
    # Verifica tutti gli ingredienti su una sola bevanda
    dark_roast = DarkRoast()
    fully_loaded = Milk(Mocha(Soy(Whip(dark_roast))))
    print(f"Description: {fully_loaded.get_description()}")
    print(f"Cost: ${fully_loaded.cost():.2f}")

elif test_case == "cost_calculation_test":
    # Verifica il calcolo dei costi per diverse combinazioni
    espresso = Espresso()
    
    # Aggiunte singole
    with_milk = Milk(espresso)
    with_mocha = Mocha(espresso)
    
    print(f"Espresso: ${espresso.cost():.2f}")
    print(f"Espresso + Milk: ${with_milk.cost():.2f}")
    print(f"Espresso + Mocha: ${with_mocha.cost():.2f}")

elif test_case == "decoration_order_test":
    # Verifica che l'ordine di aggiunta degli ingredienti non influisca sul risultato finale
    decaf = Decaf()
    
    order1 = Milk(Mocha(decaf))
    order2 = Mocha(Milk(decaf))
    
    print(f"Order 1 - {order1.get_description()}: ${order1.cost():.2f}")
    print(f"Order 2 - {order2.get_description()}: ${order2.cost():.2f}")
    print(f"Same cost: {order1.cost() == order2.cost()}")

elif test_case == "complex_order_test":
    # Verifica gli ordini di bevande complessi
    orders = [
        Mocha(Whip(Espresso())),
        Soy(Milk(HouseBlend())),
        Whip(Mocha(Soy(DarkRoast()))),
        Milk(Decaf())
    ]
    
    for i, order in enumerate(orders, 1):
        print(f"Order {i}: {order.get_description()}")
        print(f"Cost: ${order.cost():.2f}")
        print("---")

elif test_case == "double_condiment_test":
    # Verifica l'aggiunta dello stesso ingrediente più volte
    espresso = Espresso()
    double_mocha = Mocha(Mocha(espresso))
    print(f"Description: {double_mocha.get_description()}")
    print(f"Cost: ${double_mocha.cost():.2f}")

elif test_case == "beverage_comparison_test":
    # Confronta i costi di bevande diverse con gli stessi ingredienti aggiuntivi
    base_beverages = [Espresso(), HouseBlend(), DarkRoast(), Decaf()]
    
    print("All beverages with Milk + Mocha:")
    for beverage in base_beverages:
        decorated = Milk(Mocha(beverage))
        print(f"{decorated.get_description()}: ${decorated.cost():.2f}")

elif test_case == "condiment_cost_test":
    # Verifica i costi dei singoli ingredienti aggiuntivi
    espresso = Espresso()
    base_cost = espresso.cost()
    
    condiments = [
        ("Milk", Milk(espresso)),
        ("Mocha", Mocha(espresso)),
        ("Soy", Soy(espresso)),
        ("Whip", Whip(espresso))
    ]
    
    for name, decorated in condiments:
        additional_cost = decorated.cost() - base_cost
        print(f"{name} adds: ${additional_cost:.2f}")

elif test_case == "cheapest_most_expensive_test":
    # Trova le bevande base meno costose e più costose
    beverages = [
        ("Espresso", Espresso()),
        ("House Blend", HouseBlend()),
        ("Dark Roast", DarkRoast()),
        ("Decaf", Decaf())
    ]
    
    beverages.sort(key=lambda x: x[1].cost())
    print(f"Cheapest: {beverages[0][0]} - ${beverages[0][1].cost():.2f}")
    print(f"Most Expensive: {beverages[-1][0]} - ${beverages[-1][1].cost():.2f}")

elif test_case == "nested_decoration_test":
    # Verifica le decorazioni annidate in profondità
    beverage = HouseBlend()
    # Aggiungi 5 livelli di decorazioni
    decorated = Whip(Soy(Mocha(Milk(Whip(beverage)))))
    print(f"Description: {decorated.get_description()}")
    print(f"Cost: ${decorated.cost():.2f}")
    
    # Conta il numero di ingredienti aggiuntivi
    description = decorated.get_description()
    condiment_count = description.count(" + ")
    print(f"Number of condiments: {condiment_count}")

elif test_case == "cost_breakdown_test":
    # Dettaglio dei costi
    dark_roast = DarkRoast()
    print(f"Base Dark Roast: ${dark_roast.cost():.2f}")
    
    with_soy = Soy(dark_roast)
    print(f"+ Soy: ${with_soy.cost():.2f}")
    
    with_mocha = Mocha(with_soy)
    print(f"+ Mocha: ${with_mocha.cost():.2f}")
    
    with_whip = Whip(with_mocha)
    print(f"+ Whip: ${with_whip.cost():.2f}")
    
    final_cost = with_whip.cost()
    print(f"Final total: ${final_cost:.2f}")

elif test_case == "description_format_test":
    # Verifica la coerenza della formattazione della descrizione
    espresso = Espresso()
    test_combinations = [
        Milk(espresso),
        Mocha(Milk(espresso)),
        Whip(Mocha(Milk(espresso))),
        Soy(Whip(Mocha(Milk(espresso))))
    ]
    
    for combo in test_combinations:
        description = combo.get_description()
        print(f"Description: '{description}'")
        # Controlla se la descrizione inizia con il nome della bevanda base
        starts_correctly = description.startswith("Espresso")
        print(f"Starts with base name: {starts_correctly}")
        print("---")