Python高级技术之：`Python`的`Strategy`模式：如何实现可插拔的算法。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

嘿，大家好！今天咱们来聊聊Python的Strategy模式，这玩意儿可是个好东西，能让你的代码变得像乐高积木一样，想换个算法就换个算法，灵活得不要不要的。

一、啥是Strategy模式？别搞得神神秘秘的。

简单来说，Strategy模式就是定义一系列的算法，并将每个算法封装起来，使它们可以互相替换，并且让算法的变化独立于使用算法的客户。听起来有点绕？没关系，咱用人话解释：

假设你要去旅行，去不同的地方可能选择不同的交通方式：

去隔壁城市：坐高铁🚄
去国外：坐飞机✈️
去郊区：开车🚗

这里的“去旅行”就是你的主程序，而“高铁”、“飞机”、“开车”就是不同的策略（Strategy）。你可以根据不同的目的地（也就是不同的条件），选择不同的策略。

二、Strategy模式的组成部分，一个都不能少。

Strategy模式主要由以下几个部分组成：

Context（环境类）： 负责维护一个Strategy对象的引用，并定义一个执行策略的方法。就像你这个“人”，知道要“去旅行”，并且决定使用哪个交通工具。
Strategy（策略接口）： 定义所有策略类需要实现的接口。就像“交通工具”这个抽象的概念，无论高铁、飞机还是汽车，都是交通工具。
ConcreteStrategy（具体策略类）： 实现Strategy接口的具体算法。就像高铁、飞机、汽车这些具体的交通工具。

可以用一个表格来总结一下：

组件	说明	比喻
Context	维护一个Strategy对象的引用，并执行策略。	人
Strategy	定义所有策略类需要实现的接口。	交通工具
ConcreteStrategy	实现Strategy接口的具体算法。	高铁/飞机/汽车

三、Python代码实战：让你的代码活起来！

光说不练假把式，咱们直接上代码，用Python来演示一下Strategy模式。

场景： 一个简单的计算器，可以进行加法、减法、乘法、除法运算。

1. Strategy（策略接口）： 定义一个计算的接口。

from abc import ABC, abstractmethod

class CalculationStrategy(ABC):
    """
    计算策略接口
    """
    @abstractmethod
    def execute(self, num1, num2):
        """
        执行计算
        """
        pass

2. ConcreteStrategy（具体策略类）： 实现不同的计算策略。

class AddStrategy(CalculationStrategy):
    """
    加法策略
    """
    def execute(self, num1, num2):
        return num1 + num2

class SubtractStrategy(CalculationStrategy):
    """
    减法策略
    """
    def execute(self, num1, num2):
        return num1 - num2

class MultiplyStrategy(CalculationStrategy):
    """
    乘法策略
    """
    def execute(self, num1, num2):
        return num1 * num2

class DivideStrategy(CalculationStrategy):
    """
    除法策略
    """
    def execute(self, num1, num2):
        if num2 == 0:
            raise ValueError("除数不能为0")
        return num1 / num2

3. Context（环境类）： 使用策略的对象。

class Calculator:
    """
    计算器类
    """
    def __init__(self, strategy: CalculationStrategy):
        self.strategy = strategy

    def set_strategy(self, strategy: CalculationStrategy):
        """
        设置策略
        """
        self.strategy = strategy

    def calculate(self, num1, num2):
        """
        执行计算
        """
        return self.strategy.execute(num1, num2)

4. 使用示例：

# 创建计算器对象，默认使用加法策略
calculator = Calculator(AddStrategy())

# 执行加法运算
result = calculator.calculate(10, 5)
print(f"10 + 5 = {result}")  # 输出: 10 + 5 = 15

# 切换到减法策略
calculator.set_strategy(SubtractStrategy())
result = calculator.calculate(10, 5)
print(f"10 - 5 = {result}")  # 输出: 10 - 5 = 5

# 切换到乘法策略
calculator.set_strategy(MultiplyStrategy())
result = calculator.calculate(10, 5)
print(f"10 * 5 = {result}")  # 输出: 10 * 5 = 50

# 切换到除法策略
calculator.set_strategy(DivideStrategy())
result = calculator.calculate(10, 5)
print(f"10 / 5 = {result}")  # 输出: 10 / 5 = 2.0

# 尝试除以0，会抛出异常
try:
    calculator.set_strategy(DivideStrategy())
    result = calculator.calculate(10, 0)
    print(f"10 / 0 = {result}")
except ValueError as e:
    print(f"Error: {e}")  # 输出: Error: 除数不能为0

看到了吧？我们可以随时更换计算器使用的策略，而不需要修改 Calculator 类的代码。这就是Strategy模式的魅力所在！

四、Strategy模式的优点：好处多多的！

算法可互换： 可以在运行时动态地切换算法，而无需修改客户端代码。就像换交通工具一样，想坐高铁就坐高铁，想坐飞机就坐飞机。
避免使用多重条件判断语句： 使用Strategy模式可以避免大量的if...else或switch语句，使代码更加简洁易懂。告别冗长的if else，代码清爽多了！
提高代码的可维护性和可扩展性： 每个算法都封装在独立的类中，方便修改和扩展。想增加一个新的算法？没问题，直接加个类就行了！
符合开闭原则： 对扩展开放，对修改关闭。不用修改现有代码，就能增加新的功能，简直完美！

五、Strategy模式的缺点：金无足赤，人无完人。

Strategy类增多： 每种算法都需要一个Strategy类，可能会导致类的数量增加。算法多了，类也就多了，不过为了代码的灵活性，这点牺牲是值得的。
客户端必须知道所有的Strategy类： 客户端需要了解所有可用的策略，才能做出正确的选择。就像你要知道有哪些交通工具，才能决定坐哪个。

六、Strategy模式的应用场景：哪里需要哪里搬。

需要动态选择算法： 例如，支付方式的选择（支付宝、微信、银行卡）。
需要避免使用多重条件判断语句： 例如，根据不同的用户类型，执行不同的业务逻辑。
需要对算法进行扩展： 例如，图像处理软件中，可以添加新的滤镜效果。

七、Strategy模式和其他设计模式的比较：各有所长。

Strategy vs. Template Method: Strategy模式侧重于算法的动态选择，而Template Method模式侧重于算法的骨架定义和子类的实现。一个强调“换”，一个强调“定”。
Strategy vs. State: Strategy模式侧重于算法的替换，而State模式侧重于对象状态的改变。一个强调“算法”，一个强调“状态”。
Strategy vs. Factory Method: Factory Method模式侧重于对象的创建，而Strategy模式侧重于算法的选择。一个强调“创建”，一个强调“选择”。

八、Python中的Strategy模式的进阶用法：花式操作。

使用函数作为策略： 在Python中，函数是一等公民，可以像对象一样传递。因此，可以使用函数来代替类作为策略。

def add(num1, num2):
    return num1 + num2

def subtract(num1, num2):
    return num1 - num2

class Calculator:
    def __init__(self, strategy):
        self.strategy = strategy

    def calculate(self, num1, num2):
        return self.strategy(num1, num2)

calculator = Calculator(add)
result = calculator.calculate(10, 5)
print(f"10 + 5 = {result}")  # 输出: 10 + 5 = 15

calculator = Calculator(subtract)
result = calculator.calculate(10, 5)
print(f"10 - 5 = {result}")  # 输出: 10 - 5 = 5

使用lambda表达式作为策略： lambda表达式可以创建匿名函数，可以更简洁地定义策略。

calculator = Calculator(lambda x, y: x * y)
result = calculator.calculate(10, 5)
print(f"10 * 5 = {result}")  # 输出: 10 * 5 = 50

使用dict存储策略： 可以使用字典来存储不同的策略，方便查找和使用。

strategies = {
    "add": lambda x, y: x + y,
    "subtract": lambda x, y: x - y,
    "multiply": lambda x, y: x * y,
    "divide": lambda x, y: x / y if y != 0 else "除数不能为0"
}

class Calculator:
    def calculate(self, num1, num2, operation):
        strategy = strategies.get(operation)
        if strategy:
            return strategy(num1, num2)
        else:
            return "无效的操作"

calculator = Calculator()
result = calculator.calculate(10, 5, "add")
print(f"10 + 5 = {result}")  # 输出: 10 + 5 = 15

result = calculator.calculate(10, 5, "multiply")
print(f"10 * 5 = {result}")  # 输出: 10 * 5 = 50

result = calculator.calculate(10, 0, "divide")
print(f"10 / 0 = {result}")  # 输出: 10 / 0 = 除数不能为0

九、总结：Strategy模式，让你的代码更上一层楼！

Strategy模式是一种非常有用的设计模式，它可以让你在运行时动态地选择算法，避免使用多重条件判断语句，提高代码的可维护性和可扩展性。掌握Strategy模式，可以让你的代码变得更加灵活、优雅和易于维护。

希望今天的讲解对你有所帮助！记住，代码不是死的，要让它活起来，灵活起来！咱们下次再见！

发表回复 取消回复

发表回复取消回复