《精通Python设计模式》精读:策略模式

from abc import ABC, abstractmethodclass PaymentStrategy(ABC):    """    支付策略抽象类    """    @abstractmethod    def pay(self, amount):        """        支付方法        :param amount: 支付金额        :return: 支付结果        """        passclass CreditCardPayment(PaymentStrategy):    """    信用卡支付策略    """    def __init__(self, card_number, cvv, expiry_date):        """        初始化信用卡支付        :param card_number: 卡号        :param cvv: 安全码        :param expiry_date: 有效期        """        self.card_number = card_number        self.cvv = cvv        self.expiry_date = expiry_date    def pay(self, amount):        """        执行信用卡支付        :param amount: 支付金额        :return: 支付结果        """        print(f"使用信用卡支付 ¥{amount:.2f}")        print(f"卡号: ****-****-****-{self.card_number[-4:]}")        return {"status": "success", "method": "Credit Card", "amount": amount}class AlipayPayment(PaymentStrategy):    """    支付宝支付策略    """    def __init__(self, account):        """        初始化支付宝支付        :param account: 支付宝账号        """        self.account = account    def pay(self, amount):        """        执行支付宝支付        :param amount: 支付金额        :return: 支付结果        """        print(f"使用支付宝支付 ¥{amount:.2f}")        print(f"账户: {self.account}")        return {"status": "success", "method": "Alipay", "amount": amount}class WeChatPayment(PaymentStrategy):    """    微信支付策略    """    def __init__(self, phone_number):        """        初始化微信支付        :param phone_number: 手机号        """        self.phone_number = phone_number        self.balance = 1000.0  # 模拟余额    def pay(self, amount):        """        执行微信支付        :param amount: 支付金额        :return: 支付结果        """        if self.balance >= amount:            self.balance -= amount            print(f"使用微信支付 ¥{amount:.2f}")            print(f"手机号: {self.phone_number}")            print(f"余额: ¥{self.balance:.2f}")            return {"status": "success", "method": "WeChat Pay", "amount": amount}        else:            print("余额不足！")            return {"status": "failed", "method": "WeChat Pay", "amount": amount, "message": "余额不足"}class ShoppingCart:    """    购物车上下文类    """    def __init__(self):        self.items = []        self.total = 0.0        self.payment_strategy = None    def add_item(self, item, price):        """        添加商品到购物车        :param item: 商品名称        :param price: 商品价格        """        self.items.append({"item": item, "price": price})        self.total += price        print(f"添加商品: {item}, 价格: ¥{price:.2f}, 总价: ¥{self.total:.2f}")    def set_payment_strategy(self, payment_strategy: PaymentStrategy):        """        设置支付策略        :param payment_strategy: 支付策略        """        self.payment_strategy = payment_strategy        print(f"支付方式已设置为: {payment_strategy.__class__.__name__}")    def checkout(self):        """        结账        """        if not self.payment_strategy:            print("请先选择支付方式！")            return None        print(f"开始结账，总金额: ¥{self.total:.2f}")        result = self.payment_strategy.pay(self.total)        print(f"支付结果: {result['status']}")        return result# 使用策略模式的支付系统print("=== 支付系统策略模式示例 ===")cart = ShoppingCart()# 添加商品cart.add_item("书籍", 49.90)cart.add_item("笔记本电脑", 5999.00)cart.add_item("鼠标", 59.00)# 使用信用卡支付credit_card_payment = CreditCardPayment("1234567890123456", "123", "12/25")cart.set_payment_strategy(credit_card_payment)cart.checkout()print("\n" + "="*50)# 更换支付方式为微信支付wechat_payment = WeChatPayment("13800138000")cart.set_payment_strategy(wechat_payment)cart.checkout()

class SortStrategy(ABC):    """    排序策略抽象类    """    @abstractmethod    def sort(self, data):        """        排序方法        :param data: 待排序的数据        :return: 排序后的数据        """        passclass BubbleSort(SortStrategy):    """    冒泡排序策略    """    def sort(self, data):        """        冒泡排序实现        :param data: 待排序的数据        :return: 排序后的数据        """        print("使用冒泡排序...")        arr = data.copy()        n = len(arr)        for i in range(n):            for j in range(0, n - i - 1):                if arr[j] > arr[j + 1]:                    arr[j], arr[j + 1] = arr[j + 1], arr[j]        return arrclass QuickSort(SortStrategy):    """    快速排序策略    """    def sort(self, data):        """        快速排序实现        :param data: 待排序的数据        :return: 排序后的数据        """        print("使用快速排序...")        arr = data.copy()        self._quick_sort(arr, 0, len(arr) - 1)        return arr    def _quick_sort(self, arr, low, high):        """        快速排序辅助方法        :param arr: 数组        :param low: 起始位置        :param high: 结束位置        """        if low < high:            pi = self._partition(arr, low, high)            self._quick_sort(arr, low, pi - 1)            self._quick_sort(arr, pi + 1, high)    def _partition(self, arr, low, high):        """        分区方法        :param arr: 数组        :param low: 起始位置        :param high: 结束位置        """        pivot = arr[high]        i = low - 1        for j in range(low, high):            if arr[j] <= pivot:                i += 1                arr[i], arr[j] = arr[j], arr[i]        arr[i + 1], arr[high] = arr[high], arr[i + 1]        return i + 1class MergeSort(SortStrategy):    """    归并排序策略    """    def sort(self, data):        """        归并排序实现        :param data: 待排序的数据        :return: 排序后的数据        """        print("使用归并排序...")        arr = data.copy()        self._merge_sort(arr)        return arr    def _merge_sort(self, arr):        """        归并排序辅助方法        :param arr: 数组        """        if len(arr) > 1:            mid = len(arr) // 2            left_half = arr[:mid]            right_half = arr[mid:]            self._merge_sort(left_half)            self._merge_sort(right_half)            i = j = k = 0            while i < len(left_half) and j < len(right_half):                if left_half[i] < right_half[j]:                    arr[k] = left_half[i]                    i += 1                else:                    arr[k] = right_half[j]                    j += 1                k += 1            while i < len(left_half):                arr[k] = left_half[i]                i += 1                k += 1            while j < len(right_half):                arr[k] = right_half[j]                j += 1                k += 1class DataProcessor:    """    数据处理器 - 上下文类    """    def __init__(self, sort_strategy: SortStrategy = None):        """        初始化数据处理器        :param sort_strategy: 排序策略        """        self.sort_strategy = sort_strategy or QuickSort()  # 默认使用快速排序    def set_sort_strategy(self, strategy: SortStrategy):        """        设置排序策略        :param strategy: 排序策略        """        self.sort_strategy = strategy    def process_data(self, data):        """        处理数据        :param data: 原始数据        :return: 处理后的数据        """        print(f"处理数据: {data}")        sorted_data = self.sort_strategy.sort(data)        print(f"排序结果: {sorted_data}")        return sorted_data# 使用排序策略模式print("\n=== 排序算法策略模式示例 ===")processor = DataProcessor()# 测试数据test_data = [64, 34, 25, 12, 22, 11, 90]print(f"原始数据: {test_data}")# 使用快速排序result1 = processor.process_data(test_data)# 切换为冒泡排序processor.set_sort_strategy(BubbleSort())result2 = processor.process_data(test_data)# 切换为归并排序processor.set_sort_strategy(MergeSort())result3 = processor.process_data(test_data)

class DiscountStrategy(ABC):    """    折扣策略抽象类    """    @abstractmethod    def apply_discount(self, total_amount):        """        应用折扣        :param total_amount: 原始金额        :return: 折扣后的金额        """        passclass NoDiscount(DiscountStrategy):    """    无折扣策略    """    def apply_discount(self, total_amount):        """        不应用折扣        :param total_amount: 原始金额        :return: 折扣后的金额        """        print("无折扣")        return total_amountclass PercentageDiscount(DiscountStrategy):    """    百分比折扣策略    """    def __init__(self, percentage):        """        初始化百分比折扣        :param percentage: 折扣百分比 (如 10 表示 10% 折扣)        """        self.percentage = percentage    def apply_discount(self, total_amount):        """        应用百分比折扣        :param total_amount: 原始金额        :return: 折扣后的金额        """        discount_amount = total_amount * (self.percentage / 100)        discounted_amount = total_amount - discount_amount        print(f"应用 {self.percentage}% 折扣，折扣金额: ¥{discount_amount:.2f}")        return discounted_amountclass FixedAmountDiscount(DiscountStrategy):    """    固定金额折扣策略    """    def __init__(self, discount_amount):        """        初始化固定金额折扣        :param discount_amount: 折扣金额        """        self.discount_amount = discount_amount    def apply_discount(self, total_amount):        """        应用固定金额折扣        :param total_amount: 原始金额        :return: 折扣后的金额        """        discounted_amount = max(0, total_amount - self.discount_amount)        print(f"应用 ¥{self.discount_amount:.2f} 固定折扣")        return discounted_amountclass OrderCalculator:    """    订单计算器 - 上下文类    """    def __init__(self, discount_strategy: DiscountStrategy = None):        """        初始化订单计算器        :param discount_strategy: 折扣策略        """        self.discount_strategy = discount_strategy or NoDiscount()    def set_discount_strategy(self, strategy: DiscountStrategy):        """        设置折扣策略        :param strategy: 折扣策略        """        self.discount_strategy = strategy    def calculate_total(self, base_amount, tax_rate=0.1):        """        计算订单总额        :param base_amount: 基础金额        :param tax_rate: 税率        :return: 最终金额        """        # 应用折扣        discounted_amount = self.discount_strategy.apply_discount(base_amount)        # 计算税费        tax_amount = discounted_amount * tax_rate        # 计算总额        total_amount = discounted_amount + tax_amount        print(f"基础金额: ¥{base_amount:.2f}")        print(f"折扣后金额: ¥{discounted_amount:.2f}")        print(f"税费: ¥{tax_amount:.2f}")        print(f"总计: ¥{total_amount:.2f}")        return total_amount# 使用折扣策略模式print("\n=== 折扣系统策略模式示例 ===")calculator = OrderCalculator()# 测试金额original_amount = 100.00print(f"原始订单金额: ¥{original_amount:.2f}")# 无折扣print("\n--- 无折扣 ---")total1 = calculator.calculate_total(original_amount)# 10% 折扣print("\n--- 10% 百分比折扣 ---")calculator.set_discount_strategy(PercentageDiscount(10))total2 = calculator.calculate_total(original_amount)# 15元固定折扣print("\n--- 15元固定折扣 ---")calculator.set_discount_strategy(FixedAmountDiscount(15))total3 = calculator.calculate_total(original_amount)

class PaymentStrategyFactory:    """    支付策略工厂    """    @staticmethod    def create_strategy(strategy_type, **kwargs):        """        根据类型创建支付策略        :param strategy_type: 策略类型        :param kwargs: 策略参数        :return: 支付策略实例        """        strategies = {            'credit_card': CreditCardPayment,            'alipay': AlipayPayment,            'wechat': WeChatPayment        }        if strategy_type in strategies:            strategy_class = strategies[strategy_type]            try:                return strategy_class(**kwargs)            except TypeError as e:                raise ValueError(f"创建{strategy_type}策略时参数错误: {e}")        else:            raise ValueError(f"不支持的支付策略: {strategy_type}")class DiscountStrategyFactory:    """    折扣策略工厂    """    @staticmethod    def create_strategy(strategy_type, **kwargs):        """        根据类型创建折扣策略        :param strategy_type: 策略类型        :param kwargs: 策略参数        :return: 折扣策略实例        """        strategies = {            'no_discount': NoDiscount,            'percentage': PercentageDiscount,            'fixed_amount': FixedAmountDiscount        }        if strategy_type in strategies:            strategy_class = strategies[strategy_type]            try:                if strategy_type == 'no_discount':                    return strategy_class()                elif strategy_type == 'percentage':                    return strategy_class(percentage=kwargs['percentage'])                elif strategy_type == 'fixed_amount':                    return strategy_class(discount_amount=kwargs['discount_amount'])            except KeyError as e:                raise ValueError(f"创建{strategy_type}策略时缺少必要参数: {e}")        else:            raise ValueError(f"不支持的折扣策略: {strategy_type}")# 使用策略工厂print("\n=== 策略工厂示例 ===")# 创建支付策略print("使用支付策略工厂:")credit_card_kwargs = {    'card_number': '9876543210987654',    'cvv': '456',    'expiry_date': '11/26'}alipay_kwargs = {    'account': 'user@example.com'}credit_strategy = PaymentStrategyFactory.create_strategy('credit_card', **credit_card_kwargs)alipay_strategy = PaymentStrategyFactory.create_strategy('alipay', **alipay_kwargs)# 测试策略order_calculator = OrderCalculator()order_calculator.set_discount_strategy(    DiscountStrategyFactory.create_strategy('percentage', percentage=15))print(f"使用策略工厂计算订单: ¥{order_calculator.calculate_total(200.00):.2f}")# 使用上下文管理器模式print("\n=== 策略上下文管理器示例 ===")class StrategyContext:    """    策略上下文管理器    """    def __init__(self, context, strategy):        """        初始化策略上下文        :param context: 上下文对象        :param strategy: 策略对象        """        self.context = context        self.original_strategy = context.discount_strategy        self.temp_strategy = strategy    def __enter__(self):        """        进入上下文时应用临时策略        """        self.context.discount_strategy = self.temp_strategy        return self.context    def __exit__(self, exc_type, exc_value, traceback):        """        离开上下文时恢复原始策略        """        self.context.discount_strategy = self.original_strategy# 使用上下文管理器calculator = OrderCalculator()print(f"原始策略下计算: ¥{calculator.calculate_total(100.00):.2f}")with StrategyContext(calculator, PercentageDiscount(20)) as calc:    print(f"临时20%折扣下计算: ¥{calc.calculate_total(100.00):.2f}")print(f"恢复原始策略后计算: ¥{calculator.calculate_total(100.00):.2f}")

from typing import Callable, Listimport functools# 使用函数作为策略def bubble_sort_func(data: List[int]) -> List[int]:    """冒泡排序函数"""    print("使用函数式冒泡排序...")    arr = data.copy()    n = len(arr)    for i in range(n):        for j in range(0, n - i - 1):            if arr[j] > arr[j + 1]:                arr[j], arr[j + 1] = arr[j + 1], arr[j]    return arrdef quick_sort_func(data: List[int]) -> List[int]:    """快速排序函数"""    print("使用函数式快速排序...")    if len(data) <= 1:        return data    pivot = data[len(data) // 2]    left = [x for x in data if x < pivot]    middle = [x for x in data if x == pivot]    right = [x for x in data if x > pivot]    return quick_sort_func(left) + middle + quick_sort_func(right)def merge_sort_func(data: List[int]) -> List[int]:    """归并排序函数"""    print("使用函数式归并排序...")    if len(data) <= 1:        return data    mid = len(data) // 2    left = merge_sort_func(data[:mid])    right = merge_sort_func(data[mid:])    return merge_func(left, right)def merge_func(left: List[int], right: List[int]) -> List[int]:    """合并函数"""    result = []    i = j = 0    while i < len(left) and j < len(right):        if left[i] <= right[j]:            result.append(left[i])            i += 1        else:            result.append(right[j])            j += 1    result.extend(left[i:])    result.extend(right[j:])    return resultclass FunctionalSorter:    """    函数式排序器    """    def __init__(self, sort_func: Callable[[List[int]], List[int]] = None):        """        初始化排序器        :param sort_func: 排序函数        """        self.sort_func = sort_func or quick_sort_func    def set_sort_func(self, sort_func: Callable[[List[int]], List[int]]):        """        设置排序函数        :param sort_func: 排序函数        """        self.sort_func = sort_func    def sort(self, data: List[int]) -> List[int]:        """        执行排序        :param data: 待排序数据        :return: 排序后数据        """        print(f"原始数据: {data}")        sorted_data = self.sort_func(data)        print(f"排序结果: {sorted_data}")        return sorted_data# 使用函数式策略模式print("\n=== 函数式策略模式示例 ===")functional_sorter = FunctionalSorter()test_data = [34, 7, 23, 32, 5, 62]print(f"测试数据: {test_data}")# 使用不同的函数式策略result1 = functional_sorter.sort(test_data)functional_sorter.set_sort_func(bubble_sort_func)result2 = functional_sorter.sort(test_data)functional_sorter.set_sort_func(merge_sort_func)result3 = functional_sorter.sort(test_data)

from enum import Enumfrom typing import Dict, Typeclass StrategyType(Enum):    """策略类型枚举"""    CREDIT_CARD = "credit_card"    ALIPAY = "alipay"    WECHAT = "wechat"    NO_DISCOUNT = "no_discount"    PERCENTAGE_DISCOUNT = "percentage"class PaymentStrategyManager:    """    支付策略管理器 - 最佳实践    """    _strategies: Dict[StrategyType, Type[PaymentStrategy]] = {        StrategyType.CREDIT_CARD: CreditCardPayment,        StrategyType.ALIPAY: AlipayPayment,        StrategyType.WECHAT: WeChatPayment,    }    @classmethod    def register_strategy(cls, strategy_type: StrategyType, strategy_class: Type[PaymentStrategy]):        """        注册策略        :param strategy_type: 策略类型        :param strategy_class: 策略类        """        cls._strategies[strategy_type] = strategy_class    @classmethod    def create_strategy(cls, strategy_type: StrategyType, **kwargs) -> PaymentStrategy:        """        创建策略        :param strategy_type: 策略类型        :param kwargs: 策略参数        :return: 策略实例        """        if strategy_type not in cls._strategies:            raise ValueError(f"不支持的策略类型: {strategy_type}")        strategy_class = cls._strategies[strategy_type]        try:            return strategy_class(**kwargs)        except TypeError as e:            raise ValueError(f"创建{strategy_type}策略时参数错误: {e}")# 使用最佳实践的策略模式print("\n=== 策略模式最佳实践 ===")# 创建购物车cart = ShoppingCart()cart.add_item("手机", 3999.00)# 使用策略管理器credit_strategy = PaymentStrategyManager.create_strategy(    StrategyType.CREDIT_CARD,    card_number="1111222233334444",    cvv="789",    expiry_date="10/27")alipay_strategy = PaymentStrategyManager.create_strategy(    StrategyType.ALIPAY,    account="customer@example.com")cart.set_payment_strategy(credit_strategy)result1 = cart.checkout()cart.set_payment_strategy(alipay_strategy)result2 = cart.checkout()print(f"订单1结果: {result1}")print(f"订单2结果: {result2}")

from typing import Protocolclass Sortable(Protocol):    """    可似协议（仅用于类型提示）    """    def sort(self, data: List[int]) -> List[int]:        ...class FlexibleSorter:    """    灵活的排序器，支持多种策略方式    """    def __init__(self, strategy):        """        初始化排序器        :param strategy: 排序策略（可以是对象或函数）        """        self.strategy = strategy    def sort(self, data: List[int]) -> List[int]:        """        执行排序        :param data: 待排序数据        :return: 排序后数据        """        # 如果策略是函数，直接调用        if callable(self.strategy):            return self.strategy(data)        # 如果策略是对象，调用其sort方法        else:            return self.strategy.sort(data)# 使用不同类型的策略print("\n=== Python风格策略模式示例 ===")data = [64, 34, 25, 12, 22, 11, 90]# 使用函数策略func_sorter = FlexibleSorter(quick_sort_func)result_func = func_sorter.sort(data)print(f"函数策略结果: {result_func}")# 使用对象策略obj_sorter = FlexibleSorter(MergeSort())result_obj = obj_sorter.sort(data)print(f"对象策略结果: {result_obj}")# 使用lambda策略lambda_sorter = FlexibleSorter(lambda x: sorted(x))result_lambda = lambda_sorter.sort(data)print(f"Lambda策略结果: {result_lambda}")