在面向对象编程中，设计模式为常见问题提供了可重用的解决方案。策略模式是行为设计模式中最广泛使用的一种，它允许在运行时选择算法。本文将全面介绍如何在Python中理解和实现策略模式。

什么是策略模式？

策略模式定义了一系列算法，将每个算法封装起来，并使它们可以互换。它允许算法独立于使用它们的客户端而变化。

核心组件

• 上下文(Context)：维护一个指向策略对象的引用
• 策略(Strategy)：所有支持算法的公共接口
• 具体策略(Concrete Strategies)：策略接口的具体实现

基础实现

让我们从一个简单的支付系统示例开始：

from abc import ABC, abstractmethod# 策略接口
class PaymentStrategy(ABC):@abstractmethoddef pay(self, amount):pass# 具体策略实现
class CreditCardPayment(PaymentStrategy):def __init__(self, name, card_number, cvv):self.name = nameself.card_number = card_numberself.cvv = cvvdef pay(self, amount):print(f"使用信用卡支付 ${amount}，卡号尾号 {self.card_number[-4:]}")class PayPalPayment(PaymentStrategy):def __init__(self, email):self.email = emaildef pay(self, amount):print(f"使用PayPal支付 ${amount}，账户 {self.email}")class BitcoinPayment(PaymentStrategy):def __init__(self, wallet_address):self.wallet_address = wallet_addressdef pay(self, amount):print(f"使用比特币支付 ${amount}，钱包地址 {self.wallet_address[:8]}...")# 上下文
class ShoppingCart:def __init__(self):self.items = []self.payment_strategy = Nonedef add_item(self, item, price):self.items.append((item, price))def set_payment_strategy(self, strategy):self.payment_strategy = strategydef calculate_total(self):return sum(price for item, price in self.items)def checkout(self):if not self.payment_strategy:raise Exception("未设置支付策略")total = self.calculate_total()self.payment_strategy.pay(total)# 使用示例
cart = ShoppingCart()
cart.add_item("笔记本电脑", 1200)
cart.add_item("鼠标", 25)# 使用信用卡支付
cart.set_payment_strategy(CreditCardPayment("张三", "1234567890123456", "123"))
cart.checkout()# 使用PayPal支付
cart.set_payment_strategy(PayPalPayment("zhangsan@example.com"))
cart.checkout()

利用Python特性的高级实现

Python的动态特性允许更灵活的实现：

from enum import Enum
from typing import Callable# 使用函数作为策略
def bubble_sort(data):print("使用冒泡排序")# 实现细节return sorted(data)def quick_sort(data):print("使用快速排序")# 实现细节return sorted(data)def merge_sort(data):print("使用归并排序")# 实现细节return sorted(data)# 策略枚举
class SortStrategy(Enum):BUBBLE = bubble_sortQUICK = quick_sortMERGE = merge_sortclass Sorter:def __init__(self, strategy: SortStrategy):self.strategy = strategydef sort(self, data):return self.strategy.value(data)# 使用示例
data = [64, 34, 25, 12, 22, 11, 90]
sorter = Sorter(SortStrategy.QUICK)
result = sorter.sort(data)

使用装饰器的策略模式

# 策略注册装饰器
strategies = {}def register_strategy(name):def decorator(func):strategies[name] = funcreturn funcreturn decorator@register_strategy("discount_10")
def ten_percent_discount(price):return price * 0.9@register_strategy("discount_20")
def twenty_percent_discount(price):return price * 0.8@register_strategy("holiday_special")
def holiday_discount(price):return price * 0.7 if price > 100 else priceclass PriceCalculator:def __init__(self, strategy_name):self.strategy = strategies.get(strategy_name)if not self.strategy:raise ValueError(f"未知的策略: {strategy_name}")def calculate(self, price):return self.strategy(price)# 使用示例
calculator = PriceCalculator("holiday_special")
final_price = calculator.calculate(150)
print(f"最终价格: ${final_price}")

策略模式的优势

1. 算法可以自由切换：可以在运行时动态更换算法
2. 避免使用多重条件判断：替代大量的if-else或switch语句
3. 扩展性良好：可以方便地添加新的算法
4. 符合开闭原则：对扩展开放，对修改关闭

策略模式的适用场景

1. 多个类只有算法不同：当系统中存在大量相似的类，只有行为不同时
2. 需要算法动态切换：需要在运行时选择不同的算法
3. 消除复杂的条件分支：替代复杂的if-else或switch语句
4. 算法需要独立变化：算法的变化不应影响客户端

实际应用案例：电商折扣系统

from abc import ABC, abstractmethod
from datetime import datetimeclass DiscountStrategy(ABC):@abstractmethoddef calculate_discount(self, original_price, quantity):passclass NoDiscount(DiscountStrategy):def calculate_discount(self, original_price, quantity):return original_price * quantityclass BulkDiscount(DiscountStrategy):def calculate_discount(self, original_price, quantity):if quantity >= 10:return original_price * quantity * 0.9  # 10%折扣return original_price * quantityclass SeasonalDiscount(DiscountStrategy):def calculate_discount(self, original_price, quantity):# 假设夏季有折扣current_month = datetime.now().monthif 6 <= current_month <= 8:return original_price * quantity * 0.85  # 15%折扣return original_price * quantityclass MemberDiscount(DiscountStrategy):def __init__(self, is_vip=False):self.is_vip = is_vipdef calculate_discount(self, original_price, quantity):if self.is_vip:return original_price * quantity * 0.8  # 20%折扣return original_price * quantity * 0.95    # 5%折扣class Order:def __init__(self, product_name, price, quantity):self.product_name = product_nameself.price = priceself.quantity = quantityself.discount_strategy = NoDiscount()def set_discount_strategy(self, strategy):self.discount_strategy = strategydef get_total(self):return self.discount_strategy.calculate_discount(self.price, self.quantity)# 使用示例
order = Order("商品A", 100, 15)
print(f"原价: ${order.get_total()}")  # 1500# 设置批量折扣
order.set_discount_strategy(BulkDiscount())
print(f"批量折扣后: ${order.get_total()}")  # 1350# 设置会员折扣
order.set_discount_strategy(MemberDiscount(is_vip=True))
print(f"会员折扣后: ${order.get_total()}")  # 1200

注意事项

1. 策略数量：如果策略很少且不经常变化，可能不需要使用策略模式
2. 客户端了解策略：客户端必须了解不同策略的区别才能选择合适的策略
3. 对象数量增加：每种策略都需要创建一个策略类，可能会增加系统中的对象数量

总结

策略模式是一种非常实用的设计模式，特别适合处理算法需要动态切换的场景。通过将算法封装在独立的类中，可以实现算法的灵活替换，同时保持代码的清晰和可维护性。在Python中，我们可以利用其动态特性，使用函数、装饰器等方式来简化策略模式的实现。