python使用一等函数简化设计模式

在Python中，由于函数作为一等对象的能力，可以用来简化多种传统的设计模式。

一般来说，设计模式要求组件实现单方法接口而该方法有一个很宽泛的名称，例如run do execute等，通常可以使用作为一等对象的函数来简化。

核心思想是把实现单方法接口的类的实例替换为函数。每个Python可调用对象都实现了单方法接口，这个方法就是__call__

策略模式

策略模式是一种行为设计模式，它允许在运行时选择算法的行为这使得算法可以在客户端使用时互相替换。

Python简化实现：由于函数可以直接被赋值给变量，我们可以用函数来代替传统的策略类。这简化了代码并增强了灵活性。

def strategy_add(a, b):
    return a + b

def strategy_subtract(a, b):
    return a - b

def execute_strategy(strategy, a, b):
    return strategy(a, b)

# 使用
print(execute_strategy(strategy_add, 7, 3))
print(execute_strategy(strategy_subtract, 7, 3))

模板方法模式

模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下重新定义算法的某些特定步骤。

Python简化实现： 可以使用函数参数（通常是高阶函数）来替代继承和多态性，这样就可以将特定步骤的实现作为参数传入方法中。示例：

def template_method(base_func, detailed_func):
    print("Step 1: Common step")
    result = detailed_func()  # 委托子类行为的地方
    print(f"Step 2: {result}")
    base_func()

def base_function():
    print("Base function step")
def custom_function():
    return "Custom function executed"

# 使用
template_method(base_function, custom_function)

访问者模式

访问者模式是一种将算法与其操作的对象结构分离的方法。这样做的好处是可以在不修改已有程序结构的情况下向已有的对象结构中添加新的操作。有复杂的算法需要应用到对象结构中而又想保持对象结构的简洁，访问者模式可以将算法逻辑封装在访问者中从而保持元素类的简洁和通用性。

Python简化实现： 利用Python的一等函数特性，可以直接传递函数来实现对不同元素的操作，而不需要定义多个访问者类。访问者模式的核心：一个元素接受一个访问者，访问者执行一些操作。这个操作可以根据访问者的不同而不同。示例：

class Element:
    def accept(self, visitor):
        visitor.visit(self)

    def feature(self):
        return "Element Feature"

class SimpleVisitor:
    def visit(self, element):
        print(f"Accessing {element.feature()}")

# 使用
element = Element()
visitor = SimpleVisitor()

element.accept(visitor)

装饰器模式（Decorator Pattern）

装饰器模式提供了一种动态地添加职责到对象的方式，而无需修改现有的代码。

Python简化实现：在Python中，装饰器是这一模式的天然实现。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

命令模式

命令模式通常用于将一个请求封装为一个对象。目的是解耦调用操作的对象（调用者）和提供实现的对象（接收者）。例如调用者是图形应用程序中的菜单项，而接收者是被编辑的文档或应用程序自身。这个模式的做法是在二者之间放一个 Command 对象。

Python简化实现： Python可以利用函数来直接代替这些对象。示例：

def command_print():
    print("Hello World")
def execute_command(command):
    command()

# 使用
execute_command(command_print)

观察者模式

观察者模式用于通知多个对象关于某个事件的发生。

Python简化实现： 在Python中可以使用列表存储函数，并在事件发生时遍历并调用这些函数。示例：

observers = []

def event_occurred():
    for observer in observers:
        observer()

def observer1():
    print("Observer 1 notified.")

def observer2():
    print("Observer 2 notified.")

observers.append(observer1)
observers.append(observer2)

# 触发事件
event_occurred()

不使用函数对象的实现方式时只能使用传统方式

在Python中的传统实现通常会依赖于类的继承和多态性。以下是"模板方法"传统实现示例。

from abc import ABC, abstractmethod
class AbstractClass(ABC):
    # 这是一个模板方法，它定义了一个算法的框架
    def template_method(self):
        self.step_one()
        self.step_two()
    def step_one(self):
        print("Abstract: Step one is common and not overridden")
    @abstractmethod
    def step_two(self):
        pass

class ConcreteClass(AbstractClass):
    def step_two(self):
        print("Concrete: Step two is customized by subclass")

# 使用
concrete = ConcreteClass()
concrete.template_method()