Design pattern in Python

Il design pattern Strategy in Python

In questa lezione userai il pattern Strategy per scegliere e cambiare l'algoritmo mentre il programma è in esecuzione.

  • Avanzato
  • 2 min di lettura
  • 1 esempio eseguibile

Introduzione

Il problema

Il prezzo si può calcolare in modo diverso per i clienti normali, per gli iscritti o durante i saldi. Se metti tutte le regole in una sola funzione con una lunga catena di if / elif, la funzione cresce a ogni nuova regola. Con Strategy inserisci solo la regola che ti serve.

Immaginalo così

Il pattern Strategy è come scegliere un percorso in un'app di navigazione: il più veloce, il più breve o senza pedaggi. Il viaggio è lo stesso: scegli la strategia di percorso che preferisci e l'app la segue, senza cambiare il modo in cui ti guida.

Dalla scelta del percorso al codice
regular_discount, member_discount🗺️ I percorsi disponibili
Checkout(member_discount)📍 Scegline uno quando parti
self.discount_strategy(amount)🚗 Segui il percorso scelto
12.00💳 Il prezzo da iscritto su 15
L'algoritmo si inserisce dall'esterno, non è scritto fisso nel codice.
In una frase

Il pattern Strategy mette ogni variante di un algoritmo dietro la stessa interfaccia, qui una funzione con gli stessi parametri, e permette a chi chiama di scegliere quale usare.

Punti chiave

  1. regular_discount e member_discount prendono un totale e restituiscono l'importo da pagare.
  2. Checkout riceve una delle due come discount_strategy.
  3. total(amount) chiama la strategia salvata senza sapere quale sia.
  4. member_discount fa il 20% di sconto, quindi 15 diventa 12.00.

Quando si usa?

  • Regole intercambiabili: prezzi, ordinamento, validazione, formati di file.
  • Sostituire lunghe catene di if / elif che scelgono tra algoritmi.
  • Usare nei test strategie finte e semplici.

Quando non serve

  • Solo una o due regole semplici che cambiano raramente: un if è più chiaro.
  • Strategie che richiedono input molto diversi: forzarle in un'unica interfaccia diventa scomodo.

Codice di esempio

Esegui codice →
main.py
def regular_discount(total): return total
def member_discount(total): return total * 0.8


class Checkout:
    # Strategy: inject the algorithm that is allowed to vary.
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def total(self, amount):
        # Delegate the varying algorithm to the strategy.
        return self.discount_strategy(amount)


checkout = Checkout(member_discount)
print(f"{checkout.total(15):.2f}")
Crea un pulsante Run per questo esempio

Risultato dell'esecuzione

12.00

Spiegazione del codice

La classe Checkout riceve la funzione di sconto discount_strategy alla creazione e le affida tutto il calcolo nel metodo total(). Con la strategia member_discount, l'ordine da 15 diventa 12.00. Per cambiare il calcolo basta passare un'altra funzione, senza modificare la classe Checkout.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi di approfondimento

Prova a modificare il codice seguendo i suggerimenti qui sotto. Cambiare il codice e osservare il risultato ti aiuta a capire molto più che leggerlo soltanto.

  1. Sostituisci il dominio di esempio mantenendo la struttura del pattern.
  2. Confronta il pattern con un’implementazione più semplice e spiegane i compromessi.
  3. Scrivi test per ogni partecipante prima di aggiungere un’altra implementazione.
Esegui nel compilatore Python →

Errori comuni

Chiamare la strategia mentre la passi

Checkout(member_discount()) passa il risultato, non la funzione.

Problema
checkout = Checkout(member_discount())  # TypeError
Correzione
checkout = Checkout(member_discount)

Hai finito questa lezione?

Segnala come imparata per tenere traccia dei tuoi progressi.

Esercitati con una sfida

Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.

Tutte le sfide