Python设计模式中的策略模式详解

策略模式简介

策略模式（Strategy Pattern）属于对象行为型模式。定义一系列算法 (算法族)，将每个算法封装起来，让它们可以相互替换，使得算法的变化不会影响到使用算法的用户。

策略模式主要包含三个角色：

• Context（环境类）：上下文类，它通过一个成员变量将策略类传入上下文类中。
• Strategy（抽象策略类）：策略的抽象类或者接口，其定义了所有具体策略类所需的接口。
• ConcreteStrategy（具体策略类）：具体的策略类，实现抽象策略类定义的接口，提供具体的算法实现。

策略模式的优点

• 策略模式提供了针对一组算法或行为的可互换对象群，让执行算法的对象和其客户端能够相互独立。
• 策略模式为客户端提供多种算法或行为选择，可以更易于扩展应用。
• 策略模式提供了一个明确的界面，可以有效地将算法从其他部分隔离开来。

策略模式的示例应用

下面通过两个示例来演示策略模式的应用。

示例1：商场打折

假设商场在进行促销活动时，打折力度不同。那么我们就可以利用策略模式来实现不同打折策略。

from abc import ABC, abstractmethod

class DiscountStrategy(ABC):
    """打折策略抽象类"""
    @abstractmethod
    def discount(self, price):
        pass

class FullDiscount(DiscountStrategy):
    """全额打折"""
    def discount(self, price):
        return price

class HalfDiscount(DiscountStrategy):
    """半额打折"""
    def discount(self, price):
        return price * 0.5

class QuarterDiscount(DiscountStrategy):
    """四分之一打折"""
    def discount(self, price):
        return price * 0.25

class Context:
    """环境类"""
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def set_discount_strategy(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def apply_discount(self, price):
        return self.discount_strategy.discount(price)

上面的代码定义了一个抽象类 DiscountStrategy 和三个具体的策略类 FullDiscount、HalfDiscount 和 QuarterDiscount，分别实现全额打折、半额打折和四分之一打折的功能。Context 类则作为策略类的上下文类，实现 apply_discount 方法用于计算价格。

运行测试代码：

price = 100
context = Context(FullDiscount())
assert context.apply_discount(price) == price
context.set_discount_strategy(HalfDiscount())
assert context.apply_discount(price) == 50
context.set_discount_strategy(QuarterDiscount())
assert context.apply_discount(price) == 25

示例2：排序算法

另一个示例是排序算法。假设我们要对一个列表进行排序，而排序算法有多种，那么就可以使用策略模式来实现。

from abc import ABC, abstractmethod

class SortingStrategy(ABC):
    """排序策略抽象类"""
    @abstractmethod
    def sort(self, data):
        pass

class BubbleSort(SortingStrategy):
    """冒泡排序"""
    def sort(self, data):
        for i in range(len(data)):
            for j in range(len(data) - i - 1):
                if data[j] > data[j+1]:
                    data[j], data[j+1] = data[j+1], data[j]
        return data

class QuickSort(SortingStrategy):
    """快速排序"""
    def sort(self, data):
        if len(data) < 2:
            return data
        pivot = data[0]
        left = [x for x in data[1:] if x <= pivot]
        right = [x for x in data[1:] if x > pivot]
        return self.sort(left) + [pivot] + self.sort(right)

class Context:
    """环境类"""
    def __init__(self, sorting_strategy):
        self.sorting_strategy = sorting_strategy

    def set_sorting_strategy(self, sorting_strategy):
        self.sorting_strategy = sorting_strategy

    def sort(self, data):
        return self.sorting_strategy.sort(data)

上面的代码定义了一个抽象类 SortingStrategy 和两个具体的排序策略类 BubbleSort 和 QuickSort，分别实现冒泡排序和快速排序的功能。Context 类则作为排序策略类的上下文类，实现 sort 方法用于对数据进行排序。

运行测试代码：

data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
context = Context(BubbleSort())
assert context.sort(data) == [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
context.set_sorting_strategy(QuickSort())
assert context.sort(data) == [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

总结

策略模式是一种非常有用的设计模式，通过它可以将算法和实现进行分离，降低了代码的耦合度，同时也让代码更加灵活和易于扩展。在实际开发中，如果一个问题可以有多种解决方案，那么就可以考虑使用策略模式来实现。