Design pattern in Python

Il design pattern State in Python

In questa lezione userai il pattern State per cambiare il comportamento di un oggetto quando cambia il suo stato interno.

  • Avanzato
  • 3 min di lettura
  • 1 esempio eseguibile

Introduzione

Il problema

Un lettore multimediale si comporta in modo diverso quando sta suonando, è in pausa o è fermo. Se scrivi un unico grande metodo pieno di controlli if state == ..., ogni nuovo stato ti costringe a modificare tutti i metodi. Il pattern State dà a ogni stato il suo oggetto.

Immaginalo così

Il pattern State è come l'unico tasto play/pausa di un lettore musicale. Lo stesso tasto fa cose diverse a seconda di cosa sta facendo il lettore in quel momento: se sta suonando mette in pausa, se è in pausa riparte. Cambiare stato cambia quello che fa il tasto, senza dover ricostruire il lettore.

Dal tasto play/pausa al codice
Paused(), Playing()⏯️ Le due cose che il lettore può fare
self.state💡 Cosa sta facendo in questo momento
player.set_state(Playing())🔁 Passa all'altro stato
self.state.action()👆 Il tasto chiede allo stato attuale cosa fare
È l'oggetto stato attuale a decidere come si comporta il lettore.
In una frase

Il pattern State permette a un oggetto di cambiare comportamento quando cambia il suo stato interno, affidando il lavoro a un oggetto separato per ogni stato.

Punti chiave

  1. Playing e Paused hanno entrambi un metodo action().
  2. Player parte nello stato Paused.
  3. set_state sostituisce l'oggetto stato attuale.
  4. Player.action() delega a self.state.action(), quindi il risultato cambia con lo stato.

Quando si usa?

  • Oggetti con modalità chiare: lettori multimediali, ordini, connessioni, personaggi di gioco.
  • Sostituire grandi catene di if / elif su un campo di stato.
  • Flussi di lavoro in cui ogni passo permette azioni diverse.

Quando non serve

  • Due stati semplici con una piccola differenza: basta un flag booleano.
  • Stati che condividono quasi tutto il comportamento: classi separate duplicano il codice.

Codice di esempio

Esegui codice →
main.py
class Playing:
    # State: delegate behavior to the current state object.
    def action(self): return "Playing"


class Paused:
    def action(self): return "Paused"


class Player:
    def __init__(self): self.state = Paused()
    def set_state(self, state): self.state = state

    def action(self):
        # Behavior comes from the current state object.
        return self.state.action()


player = Player()
player.set_state(Playing())
print(player.action())
player.set_state(Paused())
print(player.action())
Crea un pulsante Run per questo esempio

Risultato dell'esecuzione

Playing
Paused

Spiegazione del codice

Il metodo action() di Player non fa il lavoro da solo, ma lo affida all'oggetto di stato corrente. Dopo set_state(Playing()), il risultato è Playing. Passando a set_state(Paused()), la stessa chiamata action() dà Paused. Per aggiungere un nuovo stato basta creare un'altra classe di stato.

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

Controllare lo stato con istruzioni if

Ogni nuovo stato richiede di modificare ogni metodo.

Problema
def action(self):
    if self.state == "playing":
        return "Playing"
    return "Paused"
Correzione
def action(self):
    return self.state.action()

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