Spring SALE

Command in Python

Command is behavioral design pattern that converts requests or simple operations into objects.

The conversion allows deferred or remote execution of commands, storing command history, etc.



Usage examples: The Command pattern is pretty common in Python code. Most often it’s used as an alternative for callbacks to parameterizing UI elements with actions. It’s also used for queueing tasks, tracking operations history, etc.

Identification: The Command pattern is recognizable by behavioral methods in an abstract/interface type (sender) which invokes a method in an implementation of a different abstract/interface type (receiver) which has been encapsulated by the command implementation during its creation. Command classes are usually limited to specific actions.

Conceptual Example

This example illustrates the structure of the Command design pattern. It focuses on answering these questions:

  • What classes does it consist of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

main.py: Conceptual example

from __future__ import annotations
from abc import ABC, abstractmethod

class Command(ABC):
    The Command interface declares a method for executing a command.

    def execute(self) -> None:

class SimpleCommand(Command):
    Some commands can implement simple operations on their own.

    def __init__(self, payload: str) -> None:
        self._payload = payload

    def execute(self) -> None:
        print(f"SimpleCommand: See, I can do simple things like printing"

class ComplexCommand(Command):
    However, some commands can delegate more complex operations to other
    objects, called "receivers."

    def __init__(self, receiver: Receiver, a: str, b: str) -> None:
        Complex commands can accept one or several receiver objects along with
        any context data via the constructor.

        self._receiver = receiver
        self._a = a
        self._b = b

    def execute(self) -> None:
        Commands can delegate to any methods of a receiver.

        print("ComplexCommand: Complex stuff should be done by a receiver object", end="")

class Receiver:
    The Receiver classes contain some important business logic. They know how to
    perform all kinds of operations, associated with carrying out a request. In
    fact, any class may serve as a Receiver.

    def do_something(self, a: str) -> None:
        print(f"\nReceiver: Working on ({a}.)", end="")

    def do_something_else(self, b: str) -> None:
        print(f"\nReceiver: Also working on ({b}.)", end="")

class Invoker:
    The Invoker is associated with one or several commands. It sends a request
    to the command.

    _on_start = None
    _on_finish = None

    Initialize commands.

    def set_on_start(self, command: Command):
        self._on_start = command

    def set_on_finish(self, command: Command):
        self._on_finish = command

    def do_something_important(self) -> None:
        The Invoker does not depend on concrete command or receiver classes. The
        Invoker passes a request to a receiver indirectly, by executing a

        print("Invoker: Does anybody want something done before I begin?")
        if isinstance(self._on_start, Command):

        print("Invoker: ...doing something really important...")

        print("Invoker: Does anybody want something done after I finish?")
        if isinstance(self._on_finish, Command):

if __name__ == "__main__":
    The client code can parameterize an invoker with any commands.

    invoker = Invoker()
    invoker.set_on_start(SimpleCommand("Say Hi!"))
    receiver = Receiver()
        receiver, "Send email", "Save report"))


Output.txt: Execution result

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)

Command in Other Languages

Command in C# Command in C++ Command in Go Command in Java Command in PHP Command in Ruby Command in Rust Command in Swift Command in TypeScript