前言
-
单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局的访问点。
-
工厂模式（Factory Pattern）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
-
观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会被自动通知并更新。
-
装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不会影响到其他对象。
-
策略模式（Strategy Pattern）：定义一系列的算法，将每个算法封装起来，并使它们可以相互替换。
6.命令模式 （Command Pattern）：将请求封装成一个对象，从而使用户可以用不同的请求对客户进行参数化。
-
适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类能够一起工作。
-
外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，从而使得子系统更加容易使用。
-
状态模式（State Pattern）：允许一个对象在其内部状态改变时改变其行为。
-
模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中实现。
这些是Python中常用的设计模式，通过使用这些设计模式可以提高代码的可读性、可维护性和重用性。
命令模式
命令模式是一种行为设计模式，它允许将请求封装为一个对象，从而使得可以参数化客户端对象，队列请求，或者记录请求日志，同时支持撤销操作。
组成成分
- **Command：**命令对象，对特定的操作进行封装，用于创建不同的命令。
- **Receiver：**参数接受者，即具体操作的执行者。
- **Invoker：**调用命令的对象，由此对象来调用不同的命令对象（即命令队列的创建者）。
核心思想
- 将请求封装为对象（即封装为Command命令对象）。
- 可用不同的请求对客户进行参数化（根据不同的操作进行不同命令的参数传值）。
- 允许将请求保存在队列中。
- 提供面向对象的回调。
具体实例一
python
from abc import ABCMeta, abstractmethod
class Receiver:
"""Receiver：定义各种方法以便执行不同的操作"""
def action1(self):
print('Execute action1...')
def action2(self):
print('Execute action2...')
class Command(metaclass=ABCMeta):
"""命令对象接口：定义统一的命令执行方法"""
@abstractmethod
def execute(self):
pass
class Action1(Command):
"""命令1：用于执行操作action1"""
def __init__(self, receiver):
self.receiver = receiver
def execute(self):
self.receiver.action1()
class Action2(Command):
"""命令2：用于执行操作action2"""
def __init__(self, receiver):
self.receiver = receiver
def execute(self):
self.receiver.action2()
class Invoker:
"""创建命令队列，调用并执行队列中的命令"""
def __init__(self):
self.actions = []
def append_action(self, action):
self.actions.append(action)
def execute_actions(self):
for action in self.actions:
action.execute()
if __name__ == '__main__':
receiver = Receiver()
action1 = Action1(receiver)
action2 = Action2(receiver)
invoker = Invoker()
invoker.append_action(action1)
invoker.append_action(action2)
invoker.execute_actions()具体实例二
python
from abc import ABC, abstractmethod
# Command接口或基类
class Command(ABC):
@abstractmethod
def execute(self):
pass
# 具体的命令类
class LightOnCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_on()
class LightOffCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_off()
# 接收者类
class Light:
def turn_on(self):
print("Light is ON")
def turn_off(self):
print("Light is OFF")
# 调用者类
class RemoteControl:
def __init__(self):
self.command = None
def set_command(self, command):
self.command = command
def press_button(self):
self.command.execute()
# 客户端代码
if __name__ == "__main__":
# 创建命令对象和接收者对象
light = Light()
light_on = LightOnCommand(light)
light_off = LightOffCommand(light)
# 创建调用者对象并设置命令
remote = RemoteControl()
remote.set_command(light_on)
# 调用者通过命令执行操作
remote.press_button() # Output: Light is ON
# 修改命令对象
remote.set_command(light_off)
# 再次通过命令执行操作
remote.press_button() # Output: Light is OFFCommand是一个抽象基类，LightOnCommand和LightOffCommand 是具体的命令类，而**Light是接收者类。RemoteControl**是调用者类，它通过设置不同的命令对象来执行不同的操作。
优点
- 将操作的调用者和执行者解耦，使用Command对象来作为中间的代理者。
- 可以使用队列，以便创建和管理一系列的命令。
- 添加新的命令更加容易，且无需更改现有的代码。
- 可以使用命令模式实现重做或回滚操作，以及异步任务执行，只需要执行对应的命令即可。
缺点
- 命令模式可能需要创建许多的类和对象来进行相互的协作，所以增加了实现和维护的复杂度。
- 因为每一个命令都是一个Command类，所以如果命令过多，那实现和维护起来就更加的麻烦。
参考链接