Command Design Pattern using Python Sample


The command design pattern is a behavioural design pattern in which a request can be turned to action.

Where to use a command design pattern?

When we need to
  • Do/undo action
  • When you want pass method as an argument or when you want to call a call back function
  • When we want to log or track commands

Why use a command design pattern?

Command Design Pattern is a request-driven design pattern. A request will help choose which command needs to be executed without knowing which object.method to call. In this kind of case command, the design pattern plays a key role, making this easy by using ICommand. The command design pattern actually decouples command manager and command execution logic i.e. Actual implementation.
Players in this pattern
  • ICommand – its interface which will do action undo action
  • ConcreateCommand – the one who implements ICommand
  • Invoker – One who carries out the action
  • Receiver: One who receives action from invoker and performs action
Problem definition - Provide an interface to the user to open and close the door. If the user wants, they should be able to undo his/her last action.
This example actually showcases the use case of the do and undo action requirement. For other requirements, I will write separate articles.
Players here
  • ICommand – ICommand
  • ConcreateCommand – DoorCommand
  • Invoker – client, in our case we will client operation in main(home class) function
  • Receiver – Door
We will create an enum for performing the actions:
  1. from enum import Enum  
  3. class Action(Enum):  
  4.     DOOR_OPEN = 0,  
  5.     DOOR_CLOSE = 1   
Below is the Command abstract class which will define the contact to implement:
  1. from abc import ABC, abstractmethod  
  2. from actions import Action  
  5. class Command(ABC):  
  7.     @abstractmethod  
  8.     def execute(self, action: Action):  
  9.         pass  
  11.     @abstractmethod  
  12.     def unDoExecute(self, action: Action):  
  13.         pass  
Below is the DoorCommand class which implements the ICommand contract:
  1. from iCommand import Command  
  2. from actions import Action  
  3. from door import Door  
  5. class DoorCommand(Command):  
  7.     def __init__(self):  
  8.         self.door = Door()  
  10.     def execute(self, action: Action):  
  11.         switcher = {Action.DOOR_OPEN:, Action.DOOR_CLOSE: self.door.close}  
  12.         self.lastAction = action  
  13.         # Get the function object from switcher dictionary  
  14.         function = switcher.get(action, None)  
  15.         # Execute the function  
  16.         function()  
  18.     def unDoExecute(self):  
  19.         switcher = {Action.DOOR_OPEN: self.door.close, Action.DOOR_CLOSE:}  
  20.         # Get the function object from switcher dictionary  
  21.         function = switcher.get(self.lastAction, None)  
  22.         # Execute the function  
  23.         function()  
Below is the Door class, it actually has core logic implementation:
  1. class Door :  
  2.     def open(self):  
  3.         print("------------Door Opened---------------")  
  5.     def close(self) :  
  6.         print("------------Door Closed---------------")  
Below is the Invoker, w hich requests an action
  1. from iCommand import Command  
  2. from doorCommand import DoorCommand  
  3. from actions import Action  
  5. if __name__ == "__main__":  
  6.     command: Command = DoorCommand()  
  7.     command.execute(Action.DOOR_OPEN)  
  8.     command.execute(Action.DOOR_CLOSE)  
  9.     command.unDoExecute()   
Below is the output window
Command Design Pattern Using Python Sample


In this article, we learned about the usage of a command design pattern, mainly concentrating on the do and undo operation.