Command Design Pattern using Python Sample

Introduction

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

Example

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:

from enum import Enum
class Action(Enum):
DOOR_OPEN = 0,
DOOR_CLOSE = 1

Below is the Command abstract class which will define the contact to implement:

from abc import ABC, abstractmethod
from actions import Action
class Command(ABC):
@abstractmethod
def execute(self, action: Action):
pass
@abstractmethod
def unDoExecute(self, action: Action):
pass

Below is the DoorCommand class which implements the ICommand contract:

from iCommand import Command
from actions import Action
from door import Door
class DoorCommand(Command):
def __init__(self):
self.door = Door()
def execute(self, action: Action):
switcher = {Action.DOOR_OPEN: self.door.open, Action.DOOR_CLOSE: self.door.close}
self.lastAction = action
# Get the function object from switcher dictionary
function = switcher.get(action, None)
# Execute the function
function()
def unDoExecute(self):
switcher = {Action.DOOR_OPEN: self.door.close, Action.DOOR_CLOSE: self.door.open}
# Get the function object from switcher dictionary
function = switcher.get(self.lastAction, None)
# Execute the function
function()

Below is the Door class, it actually has core logic implementation:

class Door :
def open(self):
print("------------Door Opened---------------")
def close(self) :
print("------------Door Closed---------------")

Below is the Invoker, w hich requests an action

from iCommand import Command
from doorCommand import DoorCommand
from actions import Action
if __name__ == "__main__":
command: Command = DoorCommand()
command.execute(Action.DOOR_OPEN)
command.execute(Action.DOOR_CLOSE)
command.unDoExecute()

Below is the output window

Command Design Pattern Using Python Sample

Summary

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