Python Command Pattern

What It Is

The Command pattern turns an action into a value: an object that knows how to execute itself — and often how to undo itself. Actions as values can be stored in lists, queued, delayed, logged, and replayed.

The moment you need undo, you need commands: something must remember what was done, to do the opposite.

Example: Typing with Undo

Every word added to the document is a command with execute() and undo(). Executed commands go into a history list — undo is simply asking the last one to reverse itself.

Actions that can reverse themselves

The typo "wrold" is removed not by special code, but by the command that added it — it alone knows exactly what to take back.

Write a Python program with the Command pattern: a Command protocol with execute and undo, and an AddText command that appends a word to a document list and can remove it again. Execute two commands (the second adds a typo), keep them in a history list, print the document, undo the last command and print again.

> Output: complete Python program

Prompt

Write a Python program with the Command pattern: a Command protocol with execute and undo, and an AddText command that appends a word to a document list and can remove it again. Execute two commands (the second adds a typo), keep them in a history list, print the document, undo the last command and print again.

Output: complete Python program

from dataclasses import dataclass
from typing import Protocol

class Command(Protocol):
  def execute(self) -> None: ...
  def undo(self) -> None: ...

@dataclass
class AddText:
  doc: list[str]
  text: str

  def execute(self) -> None:
    self.doc.append(self.text)

  def undo(self) -> None:
    self.doc.pop()

doc: list[str] = []
history: list[Command] = []

for word in ["Hello", "wrold"]:
  cmd = AddText(doc, word)
  cmd.execute()
  history.append(cmd)
print("document: ", doc)

# The last command knows how to take itself back.
last = history[-1]
last.undo()
print("after undo:", doc)

When to Use It

Use it for undo/redo, action queues, macros, and audit logs — anywhere actions must be stored or reversed.

Skip it when actions are fire-and-forget. In Python, a simple queued action is often just a function appended to a list — the full pattern earns its keep only when undo or inspection is needed.

Pros and Cons

Pros: undo/redo becomes natural; actions can be queued, logged and replayed; new actions plug in without touching the invoker.

Cons: one class per action adds up fast; correct undo state is subtle — a command must capture everything needed to reverse itself.