Python的策略模式：如何使用函数和类实现策略模式，实现算法的灵活切换。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python 策略模式：函数与类的灵活切换

大家好，今天我们要深入探讨一个非常实用的设计模式：策略模式。策略模式的核心思想是将算法封装到独立的策略类中，使得可以在运行时动态地选择和切换算法，而无需修改客户端代码。这极大地提高了代码的灵活性、可维护性和可扩展性。

我们将从策略模式的基本概念出发，分别使用函数和类两种方式来实现策略模式，并分析它们的优缺点和适用场景。

1. 策略模式概述

策略模式属于行为型设计模式，它定义了一系列算法，并将每一个算法封装到一个独立的类中（或者函数中）。这些算法类（或函数）都实现了一个共同的接口，客户端可以根据需要选择不同的算法来执行。

策略模式主要包含以下几个角色：

Context（环境类）： 持有一个Strategy接口的引用，负责接收客户端的请求，并委托Strategy对象来执行具体的算法。
Strategy（策略接口）： 定义所有支持算法的公共接口。
ConcreteStrategy（具体策略类）： 实现Strategy接口，提供具体的算法实现。

策略模式的优势：

算法切换灵活： 可以在运行时动态地切换算法，而无需修改客户端代码。
代码复用性高： 相同的算法可以在不同的场景中使用。
可扩展性强： 可以方便地添加新的算法，而无需修改现有的代码。
避免使用多重条件判断： 将不同的算法封装到独立的类中，避免了在客户端代码中使用大量的 if-else 或 switch 语句。

2. 使用函数实现策略模式

在Python中，函数是一等公民，这意味着函数可以像变量一样被传递和使用。因此，我们可以使用函数来实现策略模式。

示例：计算器

假设我们需要设计一个计算器，支持加法、减法、乘法和除法四种运算。我们可以使用函数来实现策略模式，将每种运算封装到一个独立的函数中。

def add(x, y):
  """加法策略"""
  return x + y

def subtract(x, y):
  """减法策略"""
  return x - y

def multiply(x, y):
  """乘法策略"""
  return x * y

def divide(x, y):
  """除法策略"""
  if y == 0:
    raise ValueError("除数不能为0")
  return x / y

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

  def calculate(self, x, y):
    """执行计算"""
    return self.strategy(x, y)

# 客户端代码
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

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

calculator = Calculator(divide)
result = calculator.calculate(10, 5)
print(f"10 / 5 = {result}")  # 输出：10 / 5 = 2.0

try:
  calculator = Calculator(divide)
  result = calculator.calculate(10, 0)
except ValueError as e:
  print(e) # 输出：除数不能为0

代码分析：

add、subtract、multiply 和 divide 函数分别实现了加法、减法、乘法和除法策略。
Calculator 类作为环境类，持有一个 strategy 属性，该属性指向一个函数（策略）。
calculate 方法接收两个参数 x 和 y，并将它们传递给 strategy 函数来执行具体的计算。
客户端代码通过创建 Calculator 对象，并传入不同的策略函数，来实现不同的运算。

函数实现策略模式的优点：

简洁易懂： 代码简洁，易于理解和维护。
灵活： 函数可以像变量一样传递，非常灵活。

函数实现策略模式的缺点：

状态维护困难： 如果策略需要维护状态，使用函数实现会比较困难。
可扩展性略差： 当策略数量较多时，代码可能会变得混乱。

3. 使用类实现策略模式

当策略需要维护状态或者策略数量较多时，使用类来实现策略模式会更加合适。

示例：排序算法

假设我们需要设计一个排序程序，支持冒泡排序、选择排序和插入排序三种算法。我们可以使用类来实现策略模式，将每种排序算法封装到一个独立的类中。

from abc import ABC, abstractmethod

class SortStrategy(ABC):
  """排序策略接口"""
  @abstractmethod
  def sort(self, data):
    """排序方法"""
    pass

class BubbleSort(SortStrategy):
  """冒泡排序策略"""
  def sort(self, data):
    """冒泡排序实现"""
    n = len(data)
    for i in range(n):
      for j in range(0, n - i - 1):
        if data[j] > data[j + 1]:
          data[j], data[j + 1] = data[j + 1], data[j]
    return data

class SelectionSort(SortStrategy):
  """选择排序策略"""
  def sort(self, data):
    """选择排序实现"""
    n = len(data)
    for i in range(n):
      min_idx = i
      for j in range(i+1, n):
        if data[j] < data[min_idx]:
          min_idx = j
      data[i], data[min_idx] = data[min_idx], data[i]
    return data

class InsertionSort(SortStrategy):
  """插入排序策略"""
  def sort(self, data):
    """插入排序实现"""
    for i in range(1, len(data)):
      key = data[i]
      j = i-1
      while j >= 0 and key < data[j] :
          data[j + 1] = data[j]
          j -= 1
      data[j + 1] = key
    return data

class Sorter:
  """排序器类"""
  def __init__(self, strategy):
    self.strategy = strategy

  def sort(self, data):
    """执行排序"""
    return self.strategy.sort(data)

# 客户端代码
data = [5, 2, 8, 1, 9, 4]

sorter = Sorter(BubbleSort())
sorted_data = sorter.sort(data.copy())  # 使用 copy() 避免修改原始数据
print(f"冒泡排序结果：{sorted_data}")  # 输出：冒泡排序结果：[1, 2, 4, 5, 8, 9]

sorter = Sorter(SelectionSort())
sorted_data = sorter.sort(data.copy())
print(f"选择排序结果：{sorted_data}")  # 输出：选择排序结果：[1, 2, 4, 5, 8, 9]

sorter = Sorter(InsertionSort())
sorted_data = sorter.sort(data.copy())
print(f"插入排序结果：{sorted_data}")  # 输出：插入排序结果：[1, 2, 4, 5, 8, 9]

代码分析：

SortStrategy 是一个抽象基类，定义了排序策略的接口 sort 方法。
BubbleSort、SelectionSort 和 InsertionSort 类分别实现了冒泡排序、选择排序和插入排序策略，并实现了 sort 方法。
Sorter 类作为环境类，持有一个 strategy 属性，该属性指向一个 SortStrategy 对象。
sort 方法调用 strategy 对象的 sort 方法来执行具体的排序。
客户端代码通过创建 Sorter 对象，并传入不同的策略对象，来实现不同的排序算法。
注意这里使用了 data.copy()，避免直接修改原始数据，保证每次排序都从相同的数据开始。

类实现策略模式的优点：

可扩展性强： 可以方便地添加新的策略类，而无需修改现有的代码。
状态维护方便： 策略类可以维护自己的状态。
代码结构清晰： 代码结构清晰，易于理解和维护。

类实现策略模式的缺点：

代码量稍多： 相对于函数实现，代码量稍多。

4. 函数与类的选择：一个对比表格

为了更清晰地比较函数和类在策略模式中的应用，我们使用一个表格进行总结：

特性	函数实现	类实现
代码简洁性	更加简洁	相对复杂
状态维护	困难	方便
可扩展性	较差，当策略数量较多时，代码可能变得混乱	更好，易于添加新的策略
适用场景	策略逻辑简单，不需要维护状态	策略逻辑复杂，需要维护状态，策略数量较多
面向对象特性	较弱	更强，更符合面向对象的设计原则

5. 策略模式的应用场景

策略模式在实际开发中有很多应用场景，以下是一些常见的例子：

支付方式选择： 根据用户选择的支付方式（支付宝、微信、银行卡等）来执行不同的支付逻辑。
数据验证： 根据不同的数据类型（邮箱、手机号、身份证号等）来执行不同的验证规则。
压缩算法选择： 根据文件类型或用户需求选择不同的压缩算法（gzip、zip、rar等）。
缓存策略： 根据数据访问频率或重要性选择不同的缓存策略（LRU、FIFO等）。
路由选择： 在网络编程中，根据不同的目标地址选择不同的路由策略。

6. 策略模式的注意事项

在使用策略模式时，需要注意以下几点：

策略数量： 策略数量不宜过多，否则会增加代码的复杂性。
策略选择： 策略选择逻辑应该尽可能简单，避免在客户端代码中使用复杂的条件判断。
策略接口： 策略接口应该定义明确，避免出现歧义。
上下文对象： 上下文对象应该只负责接收请求和委托策略对象来执行具体的算法，不应该包含任何业务逻辑。

7. 结合工厂模式使用

策略模式经常与工厂模式结合使用。工厂模式负责创建策略对象，策略模式负责执行具体的算法。这样可以进一步解耦客户端代码和策略对象，提高代码的灵活性和可维护性。

from abc import ABC, abstractmethod

# 策略接口
class DiscountStrategy(ABC):
    @abstractmethod
    def calculate_discount(self, price):
        pass

# 具体策略类
class NewCustomerDiscount(DiscountStrategy):
    def calculate_discount(self, price):
        return price * 0.1

class RegularCustomerDiscount(DiscountStrategy):
    def calculate_discount(self, price):
        return price * 0.05

class SeniorCustomerDiscount(DiscountStrategy):
    def calculate_discount(self, price):
        return price * 0.2

# 工厂类
class DiscountStrategyFactory:
    def create_discount_strategy(self, customer_type):
        if customer_type == "new":
            return NewCustomerDiscount()
        elif customer_type == "regular":
            return RegularCustomerDiscount()
        elif customer_type == "senior":
            return SeniorCustomerDiscount()
        else:
            return None

# 环境类
class ShoppingCart:
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def calculate_total(self, price):
        discounted_price = price - self.discount_strategy.calculate_discount(price)
        return discounted_price

# 客户端代码
factory = DiscountStrategyFactory()

# 根据用户类型选择不同的折扣策略
customer_type = "senior"
discount_strategy = factory.create_discount_strategy(customer_type)

if discount_strategy:
    cart = ShoppingCart(discount_strategy)
    final_price = cart.calculate_total(100)
    print(f"Final price for {customer_type} customer: {final_price}")
else:
    print("Invalid customer type")

在这个例子中，DiscountStrategyFactory 负责根据客户类型创建不同的折扣策略对象，ShoppingCart 则使用选择的策略来计算最终价格。

8. 策略模式与模板方法模式的比较

策略模式和模板方法模式都是行为型设计模式，它们都可以用于封装算法，但它们的应用场景有所不同。

策略模式： 用于封装一系列算法，并允许客户端在运行时动态地选择算法。策略模式关注的是算法的整体替换。
模板方法模式： 用于定义一个算法的骨架，并将一些步骤延迟到子类中实现。模板方法模式关注的是算法的局部定制。

总结：算法封装，灵活选择

策略模式通过将算法封装到独立的策略类或函数中，实现了算法的灵活切换。函数实现简洁，适用于简单场景；类实现可扩展性强，适用于复杂场景。合理运用策略模式，可以提高代码的灵活性、可维护性和可扩展性。

希望今天的讲解能帮助大家更好地理解和应用策略模式。谢谢大家！

Python 策略模式：函数与类的灵活切换

发表回复 取消回复

发表回复取消回复