Python编程：策略模式

于 2025-06-27 06:45:00 发布
阅读量431 收藏 3
点赞数 17
CC 4.0 BY-SA版权
分类专栏： C++与python交互编程 文章标签： python 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WaitingHereFor/article/details/148933298

策略模式(Strategy Pattern)是一种行为设计模式，它允许你定义一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

基本概念

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

  • Context(上下文): 维护一个对Strategy对象的引用

  • Strategy(策略): 定义所有支持的算法的公共接口

  • ConcreteStrategy(具体策略): 实现Strategy接口的具体算法

Python实现示例

from abc import ABC, abstractmethod
from typing import List

# 策略接口
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: List) -> List:
        pass

# 具体策略A: 快速排序
class QuickSortStrategy(SortStrategy):
    def sort(self, data: List) -> List:
        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 self.sort(left) + middle + self.sort(right)

# 具体策略B: 冒泡排序
class BubbleSortStrategy(SortStrategy):
    def sort(self, data: List) -> List:
        print("使用冒泡排序算法")
        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 Sorter:
    def __init__(self, strategy: SortStrategy):
        self._strategy = strategy
    
    def set_strategy(self, strategy: SortStrategy):
        self._strategy = strategy
    
    def perform_sort(self, data: List) -> List:
        return self._strategy.sort(data)

# 客户端代码
if __name__ == "__main__":
    data = [5, 2, 8, 1, 9, 3]
    
    sorter = Sorter(QuickSortStrategy())
    print("初始策略:")
    result = sorter.perform_sort(data.copy())
    print("排序结果:", result)
    
    print("\n切换策略:")
    sorter.set_strategy(BubbleSortStrategy())
    result = sorter.perform_sort(data.copy())
    print("排序结果:", result)

输出示例

初始策略:
使用快速排序算法
排序结果: [1, 2, 3, 5, 8, 9]

切换策略:
使用冒泡排序算法
排序结果: [1, 2, 3, 5, 8, 9]

策略模式的优点

  1. 开闭原则：可以在不修改上下文代码的情况下引入新策略

  2. 消除条件语句：避免使用多重条件判断来选择算法

  3. 提高灵活性：运行时可以切换算法

  4. 算法复用：不同上下文可以共享策略对象

Python中的简化实现

Python支持一等函数(first-class functions)，这使得策略模式可以更简洁地实现：

from typing import List, Callable

def quick_sort(data: List) -> List:
    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(left) + middle + quick_sort(right)

def bubble_sort(data: List) -> List:
    print("使用冒泡排序算法")
    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 Sorter:
    def __init__(self, strategy: Callable[[List], List]):
        self._strategy = strategy
    
    def set_strategy(self, strategy: Callable[[List], List]):
        self._strategy = strategy
    
    def perform_sort(self, data: List) -> List:
        return self._strategy(data)

# 使用
data = [5, 2, 8, 1, 9, 3]
sorter = Sorter(quick_sort)
print(sorter.perform_sort(data.copy()))

sorter.set_strategy(bubble_sort)
print(sorter.perform_sort(data.copy()))

这种实现利用了Python的函数特性，使代码更加简洁。

订单折扣策略实现示例

"""
*What is this pattern about?
Define a family of algorithms, encapsulate each one, and make them interchangeable.
Strategy lets the algorithm vary independently from clients that use it.

*TL;DR
Enables selecting an algorithm at runtime.
"""

from __future__ import annotations

from typing import Callable


class DiscountStrategyValidator:  # Descriptor class for check perform
    @staticmethod
    def validate(obj: Order, value: Callable) -> bool:
        try:
            if obj.price - value(obj) < 0:
                raise ValueError(
                    f"Discount cannot be applied due to negative price resulting. {value.__name__}"
                )
        except ValueError as ex:
            print(str(ex))
            return False
        else:
            return True

    def __set_name__(self, owner, name: str) -> None:
        self.private_name = f"_{name}"

    def __set__(self, obj: Order, value: Callable = None) -> None:
        if value and self.validate(obj, value):
            setattr(obj, self.private_name, value)
        else:
            setattr(obj, self.private_name, None)

    def __get__(self, obj: object, objtype: type = None):
        return getattr(obj, self.private_name)


class Order:
    discount_strategy = DiscountStrategyValidator()

    def __init__(self, price: float, discount_strategy: Callable = None) -> None:
        self.price: float = price
        self.discount_strategy = discount_strategy

    def apply_discount(self) -> float:
        if self.discount_strategy:
            discount = self.discount_strategy(self)
        else:
            discount = 0

        return self.price - discount

    def __repr__(self) -> str:
        strategy = getattr(self.discount_strategy, "__name__", None)
        return f"<Order price: {self.price} with discount strategy: {strategy}>"


def ten_percent_discount(order: Order) -> float:
    return order.price * 0.10


def on_sale_discount(order: Order) -> float:
    return order.price * 0.25 + 20


def main():
    """
    >>> order = Order(100, discount_strategy=ten_percent_discount)
    >>> print(order)
    <Order price: 100 with discount strategy: ten_percent_discount>
    >>> print(order.apply_discount())
    90.0
    >>> order = Order(100, discount_strategy=on_sale_discount)
    >>> print(order)
    <Order price: 100 with discount strategy: on_sale_discount>
    >>> print(order.apply_discount())
    55.0
    >>> order = Order(10, discount_strategy=on_sale_discount)
    Discount cannot be applied due to negative price resulting. on_sale_discount
    >>> print(order)
    <Order price: 10 with discount strategy: None>
    """


if __name__ == "__main__":
    import doctest

    doctest.testmod()

正如代码开头的注释所述：

  • 策略模式定义了一系列算法（折扣策略）

  • 将每个算法封装起来

  • 使它们可以互换

  • 让算法的变化独立于使用它的客户端（Order类）

主要组件

1 DiscountStrategyValidator 类

这是一个描述符类，用于验证折扣策略的有效性：

class DiscountStrategyValidator:
    @staticmethod
    def validate(obj: Order, value: Callable) -> bool:
        try:
            if obj.price - value(obj) < 0:
                raise ValueError(
                    f"Discount cannot be applied due to negative price resulting. {value.__name__}"
                )
        except ValueError as ex:
            print(str(ex))
            return False
        else:
            return True

    def __set_name__(self, owner, name: str) -> None:
        self.private_name = f"_{name}"

    def __set__(self, obj: Order, value: Callable = None) -> None:
        if value and self.validate(obj, value):
            setattr(obj, self.private_name, value)
        else:
            setattr(obj, self.private_name, None)

    def __get__(self, obj: object, objtype: type = None):
        return getattr(obj, self.private_name)

功能解析：

  1. validate方法检查应用折扣后价格是否为负

  2. __set_name__设置私有属性名（约定为_加属性名）

  3. __set__在设置值前进行验证

  4. __get__获取属性值

2 Order 类

这是上下文类，使用策略模式：

class Order:
    discount_strategy = DiscountStrategyValidator()

    def __init__(self, price: float, discount_strategy: Callable = None) -> None:
        self.price: float = price
        self.discount_strategy = discount_strategy

    def apply_discount(self) -> float:
        if self.discount_strategy:
            discount = self.discount_strategy(self)
        else:
            discount = 0
        return self.price - discount

    def __repr__(self) -> str:
        strategy = getattr(self.discount_strategy, "__name__", None)
        return f"<Order price: {self.price} with discount strategy: {strategy}>"

关键点：

  • 使用描述符管理折扣策略

  • apply_discount方法应用当前策略

  • 可以动态更换策略

3 具体策略实现

def ten_percent_discount(order: Order) -> float:
    return order.price * 0.10

def on_sale_discount(order: Order) -> float:
    return order.price * 0.25 + 20

这是两个具体策略：

  1. ten_percent_discount: 10%折扣

  2. on_sale_discount: 25%折扣外加20元优惠

使用示例

def main():
    order = Order(100, discount_strategy=ten_percent_discount)
    print(order)
    print(order.apply_discount())

    order = Order(100, discount_strategy=on_sale_discount)
    print(order)
    print(order.apply_discount())

    order = Order(10, discount_strategy=on_sale_discount)
    Discount cannot be applied due to negative price resulting. on_sale_discount
    print(order)

测试案例说明：

  1. 第一个订单应用10%折扣，价格从100降到90

  2. 第二个订单应用促销折扣，价格从100降到55

  3. 第三个订单价格太低（10元），应用促销折扣会导致负价格，策略被拒绝

设计亮点

  1. 描述符的使用：通过描述符实现了策略的自动验证

  2. 类型提示：全面使用类型注解，提高代码可读性

  3. 防御性编程：防止无效折扣导致负价格

  4. 文档测试：使用doctest模块提供自包含的测试案例

与传统策略模式的对比

传统策略模式通常使用抽象基类定义接口，而这里利用了Python的鸭子类型和函数特性：

  • 策略只是可调用对象（Callable）

  • 不需要继承抽象基类

  • 更符合Python的简洁哲学

掌握 Python 异步编程：综合指南
gongdiwudu的专栏
01-19 3039
本综合指南旨在阐明 Python 异步编程的复杂性。它面向初学者和经验丰富的程序员，旨在提供对异步编程模型及其在 Python 中的实际应用的透彻理解。
Python教程：深入理解Python元编程
旦莫的博客
06-25 805
Python元编程是一种高级编程技术，它允许我们在运行时操作程序的结构，如类、函数和模块。这种能力使得Python代码更加灵活和动态，但也带来了一定的复杂性和潜在的风险。本文将深入探讨Python元编程的概念、技术、底层原理以及源码分析，帮助读者更好地理解和应用这一高级特性。
Python讲解：策略模式
软件架构师笔记
12-12 1095
策略模式是一种行为设计模式
Python编码系列—Python策略模式：灵活应对变化的算法策略
u013889591的专栏
09-21 1318
在软件开发中，经常会遇到需要根据不同情况执行不同算法或行为的场景。策略模式（Strategy Pattern）提供了一种优雅的方式来管理和使用这些算法，使得算法可以在运行时被选择和更换。本文将深入探讨Python中的策略模式，包括其背景、原理、使用场景、代码实现和实际应用案例。策略模式是一种行为型设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互换使用。策略模式让算法的变化独立于使用算法的客户。
Python策略模式介绍、使用方法
captain
07-26 2707
在Python中，定义类时可以带括号，也可以不带括号。# 或者带括号和不带括号的区别在于继承的方式不同。在Python 2.x版本中，带括号和不带括号的定义方式有区别，带括号的类定义方式是旧式类，不带括号的类定义方式是新式类。而在Python 3.x版本中，带括号和不带括号定义方式没有区别。新式类和旧式类的主要区别在于继承方式不同。在旧式类中，如果没有显式地指定一个特定的父类，那么Python会默认继承由内置类型object派生出的类；
Python中的策略模式：解锁编程的灵活之钥
qq_44771627的博客
09-13 808
在软件开发过程中，我们经常需要根据不同的条件或上下文来改变算法的行为。例如，在电子商务网站中，根据用户所在地区选择合适的支付方式；或者在游戏中，根据玩家等级调整敌人AI的行为。这些场景都需要我们的程序能够动态地切换算法。而这就是策略模式大显身手的地方了！
Python类的力量：第六篇：设计模式——Python面向对象编程的“架构蓝图”
dudly的博客
05-20 2190
在软件开发中，设计模式（Design Patterns）是经过反复验证的通用解决方案，能够有效解决特定场景下的设计问题。通过应用设计模式，开发者可以将复杂的业务逻辑转化为可复用的架构模块，提升代码的可维护性、扩展性和健壮性。本文将结合Python的动态特性，解析**单例模式**、**工厂模式**、**观察者模式**等经典设计模式的实现原理与行业应用，帮助读者构建“可复用、易扩展”的代码体系。
Python编程：设计模式之单例和简单工厂
彭世瑜的博客
05-30 2288
前言 设计模式： 一种解决问题的思想和方法 设计模式原则： 高内聚、低耦合 设计模式分类（三大类23种） 创建类设计模式 单例模式、简单工厂模式、工厂模式、抽象工厂模式、原型模式、建造者模式； 结构类设计模式 装饰器模式、适配器模式、门面模式、组合模式、享元模式、桥梁模式； 行为类设计模式 策略模式、责任链模式、命令模式、中介者模式、模板模式、迭代器模式、访问者模式、...
python-patterns：Python 设计模式大全
Unity打怪升级
10-02 852
python-patterns 是一个开源的 Python 项目，它提供了各种经典的设计模式的 Python 实现。设计模式是一种针对常见软件设计问题的可复用解决方案，通过使用设计模式，开发者可以编写出结构更加合理、易于维护和扩展的代码。
Python ABC：应用场景和示例
m0_67847535的博客
02-07 2256
抽象基类是Python标准库中的一个模块，用于定义抽象类和接口。它们允许我们创建具有共同行为和属性的类的模板，并要求子类实现这些行为和属性。ABC的主要目的是确保子类遵循指定的接口，以提高代码的一致性和可维护性。要使用ABC，首先需要导入abc要创建一个抽象基类，需要继承自ABC类，并使用装饰器来标记抽象方法。抽象方法是没有实际实现的方法，它们在子类中必须被重写。passpass在上面的示例中，Shape是一个抽象基类，它定义了两个抽象方法area()和。
Python线程安全编程：策略、实践与代码示例
11-06
在Python中，线程安全的实现策略主要包括使用锁、线程安全的数据结构以及条件变量。 使用锁是确保线程安全的基本工具，它可以保证在任何时刻只有一个线程可以访问共享资源。Python的`threading`模块提供了多种锁...
Python编程实战：从入门到精通的10个核心技巧
05-27
--- Python基础强化 1.1 Python核心语法精要 列表推导式让代码更简洁： 装饰器示例： 1.2 现代Python特性 类型注解提高代码可读性： 模式匹配(Python 3.10+)： --- 高效编程技巧 2.1 性能优化策略 数据结构选择对比...
Python编程 -设计模式-从入门到实践
03-14
当我们谈论“Python编程 - 设计模式 - 从入门到实践”时，这意味着我们将探讨如何在Python编程中应用这些模式来提高软件开发的效率和质量。 首先，让我们理解什么是设计模式。设计模式并不特定于任何一种编程语言，...
学习昇腾开发的第8天--python实现rtsp拉取手机摄像头视频流再通过ffmpeg推流到mediamtx服务器再通过vlc显示
xiaojin511025的博客
06-25 191
【代码】学习昇腾开发的第8天。
odoo17 激活开发者模式
fqfq123456的专栏
06-25 287
Odoo17激活开发者模式方法： URL添加?debug=1（推荐） 用户菜单手动勾选开发者模式 命令行设置系统参数（需管理员权限） 激活成功后会出现🐛图标和Debug标识，可获得技术菜单权限。注意生产环境禁用此模式以防数据泄露，通过点击虫子图标可快速切换调试状态。
python测试温度传感器写入数据库
06-22 505
测试数据库写入功能，可以用随机数生成模拟温度数据。'%H:%M:%S'
黑马python（十一）
dengfengling999的博客
06-22 584
排序的结果会变成列表对象。
Python 接口自动化测试项目
最新发布
金玉满堂的博客
06-26 178
Python 接口自动化测试项目下面是一个基于 Python 的接口自动化测试项目框架，使用 pytest + requests + allure 报告体系。项目结构│├── config/ # 配置文件目录│ ├──.py│ ├── config.py # 基础配置│ └── env.py # 环境配置│。
京东商品详情API数据清洗术：SKU反爬字段脱敏与结构化存储
2403_87277550的博客
06-23 641
表结构：product_promotion(sku_id, promo_id, type, threshold, discount){"type": "满减", "threshold": "5000", "discount": "300"},表结构：product_media(sku_id, media_type, url, width, height){"type": "白条", "periods": 6, "interest_free": true}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值