详解Python设计模式之策略模式

策略模式是什么

策略模式（Strategy Pattern）是一种行为模式，用于以相同的方式处理多个不同的行为。在策略模式中，算法被封装在独立的策略中，这使得它们易于替换、理解和扩展。此模式通过定义算法族、分别封装它们，使它们之间可以互换，此模式让算法的变化独立于使用算法的客户。

以计算器为例，有加法、减法、乘法、除法等操作。我们可以使用策略模式将每个操作的具体实现封装在各自的策略中，然后在计算器中使用相应的策略，这样就能够实现相同的接口对多个操作进行处理。

实现策略模式的步骤

1. 定义策略接口

首先，我们需要定义一个策略接口，该接口里面包含具体操作的抽象方法。

from abc import ABC, abstractmethod

class Strategy(ABC):
    @abstractmethod
    def operate(self, num1, num2):
        pass

2. 实现策略类

接下来，我们需要实现具体的策略类，该类需要继承策略接口，并实现对应的操作方法。

class Add(Strategy):
    def operate(self, num1, num2):
        return num1 + num2

class Subtract(Strategy):
    def operate(self, num1, num2):
        return num1 - num2

class Multiply(Strategy):
    def operate(self, num1, num2):
        return num1 * num2

class Divide(Strategy):
    def operate(self, num1, num2):
        return num1 / num2 if num2 != 0 else "Cannot divide by zero"

3. 实现上下文类

接下来，我们需要实现上下文类，该类负责使用相应的策略处理数据。

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

    def execute(self, num1, num2):
        return self.strategy.operate(num1, num2)

4. 使用策略模式

最后，我们需要在客户端代码中使用策略模式。

if __name__ == '__main__':
    num1 = 10
    num2 = 5

    add = Add()
    calculator = Calculator(add)
    print(calculator.execute(num1, num2))

    subtract = Subtract()
    calculator = Calculator(subtract)
    print(calculator.execute(num1, num2))

    multiply = Multiply()
    calculator = Calculator(multiply)
    print(calculator.execute(num1, num2))

    divide = Divide()
    calculator = Calculator(divide)
    print(calculator.execute(num1, num2))

通过上述代码，我们可以将加法、减法、乘法、除法操作的具体实现封装在各自的策略类中，然后在上下文类 Calculator 中使用相应的策略处理数据。

示例说明

以下代码为将不同的排序算法封装在各自的策略类中，然后在上下文类中使用相应的策略进行排序。

定义策略接口

from abc import ABC, abstractmethod

class Strategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

实现策略类

class BubbleSort(Strategy):
    def sort(self, data):
        n = len(data)

        for i in range(n):
            for j in range(n - i - 1):
                if data[j] > data[j + 1]:
                    data[j], data[j + 1] = data[j + 1], data[j]

        return data

class SelectionSort(Strategy):
    def sort(self, data):
        n = len(data)

        for i in range(n):
            min_index = i
            for j in range(i + 1, n):
                if data[j] < data[min_index]:
                    min_index = j

            data[i], data[min_index] = data[min_index], data[i]

        return data

实现上下文类

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

    def execute(self, data):
        return self.strategy.sort(data)

使用策略模式

if __name__ == '__main__':
    data = [5, 3, 8, 4, 2, 1]

    bubble_sort = BubbleSort()
    sorting_client = SortingClient(bubble_sort)
    print(sorting_client.execute(data))

    selection_sort = SelectionSort()
    sorting_client = SortingClient(selection_sort)
    print(sorting_client.execute(data))

通过上述代码，我们可以将冒泡排序和选择排序的具体实现封装在各自的策略类中，然后在上下文类 SortingClient 中使用相应的策略进行排序。