Modelul State în Python

Ce este

Șablonul Stare (State) oferă unui obiect un comportament diferit în stări diferite, transformând fiecare stare într-o clasă proprie. Obiectul își păstrează starea curentă și îi delegă ei lucrul; trecerea la o altă stare înseamnă înlocuirea valorii.

El înlocuiește lanțul if/elif tot mai lung pe un câmp de stare, repetat în jumătate din metode, cu câte o clasă mică pentru fiecare stare.

Exemplu: viața unei comenzi

O comandă este nouă, apoi plătită, apoi expediată. Fiecare clasă de stare răspunde la describe() în felul ei și știe ce stare urmează — comanda însăși nu conține deloc logică legată de stare.

Fiecare stare este o clasă

advance() rămâne mereu o singură linie. Adăugarea unei stări „livrată” înseamnă o clasă nouă plus o singură metodă next_state() modificată — fără vreun lanț if/elif prin care să cauți.

Scrie un program Python cu șablonul Stare: un protocol State cu next_state și describe, clasele de stare New, Paid și Shipped (Shipped rămâne Shipped) și o clasă Order care păstrează o stare și are o metodă advance care o înlocuiește. Trece o comandă prin toate cele trei stări, afișând fiecare descriere.

> Ieșire: program Python complet

Prompt

Scrie un program Python cu șablonul Stare: un protocol State cu next_state și describe, clasele de stare New, Paid și Shipped (Shipped rămâne Shipped) și o clasă Order care păstrează o stare și are o metodă advance care o înlocuiește. Trece o comandă prin toate cele trei stări, afișând fiecare descriere.

Ieșire: program Python complet

from typing import Protocol

class State(Protocol):
  def next_state(self) -> "State": ...
  def describe(self) -> str: ...

class New:
  def next_state(self) -> State:
    return Paid()

  def describe(self) -> str:
    return "nouă - așteaptă plata"

class Paid:
  def next_state(self) -> State:
    return Shipped()

  def describe(self) -> str:
    return "plătită - se împachetează cutia"

class Shipped:
  def next_state(self) -> State:
    return Shipped()

  def describe(self) -> str:
    return "expediată - este pe drum"

class Order:
  def __init__(self, state: State) -> None:
    self.state = state

  def advance(self) -> None:
    self.state = self.state.next_state()

o = Order(New())

print(o.state.describe())
o.advance()
print(o.state.describe())
o.advance()
print(o.state.describe())

Când să-l folosești

Folosește-l atunci când comportamentul unui obiect diferă cu adevărat în funcție de stare, iar stările au reguli reale de tranziție — comenzi, documente (ciornă/revizuire/publicat), conexiuni, personaje din jocuri.

Renunță la el atunci când o stare este doar afișată și nu schimbă niciodată comportamentul. Un câmp de tip șir și un singur if/elif sunt suficiente sub trei stări cu reguli simple.

Avantaje și dezavantaje

Avantaje: regulile fiecărei stări se află într-o singură clasă mică; tranzițiile imposibile pur și simplu nu sunt scrise; stările noi extind codul în loc să-l modifice.

Dezavantaje: multe clase mici pentru mașini de stări simple; fluxul întregii mașini este împrăștiat prin fișiere — o diagramă într-un comentariu ajută.