Python State Pattern

What It Is

The State pattern gives an object different behavior in different states by making each state its own class. The object holds its current state and delegates to it; moving to another state means swapping the value.

It replaces the growing if/elif chain on a status field, repeated through half the methods, with one small class per state.

Example: An Order's Life

An order is new, then paid, then shipped. Each state class answers describe() its own way and knows which state comes next — the order itself contains no status logic at all.

Each state is a class

advance() is one line forever. Adding a "delivered" state is a new class plus one changed next_state() — no if/elif chain to hunt through.

Write a Python program with the State pattern: a State protocol with next_state and describe, New, Paid and Shipped state classes (shipped stays shipped), and an Order holding a state with an advance method that swaps it. Walk one order through all three states, printing each description.

> Output: complete Python program

Prompt

Write a Python program with the State pattern: a State protocol with next_state and describe, New, Paid and Shipped state classes (shipped stays shipped), and an Order holding a state with an advance method that swaps it. Walk one order through all three states, printing each description.

Output: complete Python program

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 "new - waiting for payment"

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

  def describe(self) -> str:
    return "paid - packing the box"

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

  def describe(self) -> str:
    return "shipped - on its way"

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())

When to Use It

Use it when an object's behavior genuinely differs by state and the states have real rules about transitions — orders, documents (draft/review/published), connections, game characters.

Skip it when a status is only displayed, never changes behavior. A string field and one if/elif is fine below three states with simple rules.

Pros and Cons

Pros: each state's rules live in one small class; impossible transitions are simply not written; new states extend instead of modifying.

Cons: many tiny classes for simple machines; the flow of the whole machine is spread across files — a diagram in a comment helps.