第十章 使用头等函数的设计模式

最新推荐文章于 2025-12-06 13:32:24 发布
原创 最新推荐文章于 2025-12-06 13:32:24 发布 · 789 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #python

第十章 使用头等函数的设计模式

策略模式的实现案例

《设计模式》一书对策略模式的总结为定义一系列算法，将每个算法封装起来，并使它们可以互换。策略模式让算法的变化独立于使用它的客户端。

在电商领域，一个清晰的策略模式应用示例是：根据客户属性或订单商品的特征，为订单计算不同的折扣。假设某在线商店有以下折扣规则：

  • 忠诚积分达到 1,000 或以上的客户，每笔订单享受 5% 的全局折扣。
  • 同一订单中，任一商品数量达到 20 件或以上，该商品享受 10% 的折扣。
  • 订单中包含至少 10 种不同商品，则整单享受 7% 的全局折扣。

经典面向对象实现

from abc import ABC, abstractmethod
from collections.abc import Sequence
from decimal import Decimal
from typing import NamedTuple, Optional

# 客户信息：使用 NamedTuple 定义不可变客户对象
class Customer(NamedTuple):
    name: str      # 客户姓名
    fidelity: int  # 忠诚积分

# 订单中的商品项：每个商品包含名称、数量和单价
class LineItem(NamedTuple):
    product: str        # 商品名称
    quantity: int       # 数量
    price: Decimal      # 单价（使用 Decimal 精确表示货币）

    def total(self) -> Decimal:
        """计算该商品项的总价 = 单价 × 数量"""
        return self.price * self.quantity

# 订单类：代表一个客户的一次购物订单
class Order(NamedTuple):
    customer: Customer                     # 关联的客户
    cart: Sequence[LineItem]               # 购物车中的商品项列表
    promotion: Optional['Promotion'] = None  # 可选的促销策略（策略模式中的策略对象）

    def total(self) -> Decimal:
        """计算订单中所有商品的原始总价（未打折）"""
        totals = (item.total() for item in self.cart)
        return sum(totals, start=Decimal(0))

    def due(self) -> Decimal:
        """计算订单应付金额 = 原始总价 - 折扣"""
        if self.promotion is None:
            discount = Decimal(0)  # 无促销策略，折扣为 0
        else:
            # 调用策略对象的 discount 方法，传入当前订单实例
            discount = self.promotion.discount(self)
        return self.total() - discount

    def __repr__(self):
        """自定义字符串表示，便于调试和打印"""
        return f'<Order total: {self.total():.2f} due: {self.due():.2f}>'

# 抽象基类：定义所有促销策略必须实现的接口
class Promotion(ABC):
    @abstractmethod
    def discount(self, order: Order) -> Decimal:
        """返回应给予该订单的折扣金额（正数）"""
        pass

# 具体策略 1：忠诚客户折扣
class FidelityPromo(Promotion):
    """为忠诚积分达到 1000 或以上的客户，提供 5% 的全局折扣"""
    def discount(self, order: Order) -> Decimal:
        if order.customer.fidelity >= 1000:
            return order.total() * Decimal('0.05')
        return Decimal(0)

# 具体策略 2：大数量商品折扣
class BulkItemPromo(Promotion):
    """对订单中任一商品数量达到 20 件或以上的，该商品享受 10% 折扣"""
    def discount(self, order: Order) -> Decimal:
        discount = Decimal(0)
        for item in order.cart:
            if item.quantity >= 20:
                discount += item.total() * Decimal('0.1')
        return discount

# 具体策略 3：大订单折扣
class LargeOrderPromo(Promotion):
    """订单中包含 10 种或以上不同商品时，整单享受 7% 的全局折扣"""
    def discount(self, order: Order) -> Decimal:
        # 使用集合去重，统计不同商品种类数
        distinct_items = {item.product for item in order.cart}
        if len(distinct_items) >= 10:
            return order.total() * Decimal('0.07')
        return Decimal(0)

from decimal import Decimal

joe = Customer('John Doe', 0)
ann = Customer('Ann Smith', 1100)
cart = (
    LineItem('banana', 4, Decimal('.5')),
    LineItem('apple', 10, Decimal('1.5')),
    LineItem('watermelon', 5, Decimal(5))
)

print(Order(joe, cart, FidelityPromo()))        # <Order total: 42.00 due: 42.00>
print(Order(ann, cart, FidelityPromo()))        # <Order total: 42.00 due: 39.90>

banana_cart = (
    LineItem('banana', 30, Decimal('.5')),
    LineItem('apple', 10, Decimal('1.5'))
)
print(Order(joe, banana_cart, BulkItemPromo())) # <Order total: 30.00 due: 28.50>

long_cart = tuple(LineItem(str(sku), 1, Decimal(1)) for sku in range(10))
print(Order(joe, long_cart, LargeOrderPromo())) # <Order total: 10.00 due: 9.30>
print(Order(joe, cart, LargeOrderPromo()))      # <Order total: 42.00 due: 42.00>

面向函数的重构

from collections.abc import Sequence
from dataclasses import dataclass
from decimal import Decimal
from typing import Optional, Callable, NamedTuple

class Customer(NamedTuple):
    name: str
    fidelity: int

class LineItem(NamedTuple):
    product: str
    quantity: int
    price: Decimal

    def total(self) -> Decimal:
        return self.price * self.quantity

# Order 不再依赖抽象基类 Promotion
# 使用 @dataclass(frozen=True) 替代 NamedTuple
# promotion 字段类型为 Optional[Callable[['Order'], Decimal]]，
# 表示它可以是 None，也可以是一个接受 Order 实例、返回 Decimal 的函数。
@dataclass(frozen=True)
class Order:
    customer: Customer
    cart: Sequence[LineItem]
    # 不再是 Promotion 子类实例，而是函数
    promotion: Optional[Callable[['Order'], Decimal]] = None

    def total(self) -> Decimal:
        totals = (item.total() for item in self.cart)
        return sum(totals, start=Decimal(0))

    def due(self) -> Decimal:
        if self.promotion is None:
            discount = Decimal(0)
        else:
            # 直接调用函数，而非方法
            # self.promotion 是一个普通函数（非绑定方法），因此需显式传入 self
            discount = self.promotion(self)  
        return self.total() - discount

    def __repr__(self):
        return f'<Order total: {self.total():.2f} due: {self.due():.2f}>'

# 策略由函数实现，而非类
# 每个策略现在是一个独立的顶层函数，无状态、无类结构

def fidelity_promo(order: Order) -> Decimal:
    """忠诚积分 ≥1000 的客户享受 5% 折扣"""
    if order.customer.fidelity >= 1000:
        return order.total() * Decimal('0.05')
    return Decimal(0)

def bulk_item_promo(order: Order) -> Decimal:
    """单个商品数量 ≥20 时，该商品享受 10% 折扣"""
    discount = Decimal(0)
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * Decimal('0.1')
    return discount

def large_order_promo(order: Order) -> Decimal:
    """订单包含 ≥10 种不同商品时，整单享受 7% 折扣"""
    distinct_items = {item.product for item in order.cart}
    if len(distinct_items) >= 10:
        return order.total() * Decimal('0.07')
    return Decimal(0)

from decimal import Decimal

joe = Customer('John Doe', 0)
ann = Customer('Ann Smith', 1100)
cart = [
    LineItem('banana', 4, Decimal('.5')),
    LineItem('apple', 10, Decimal('1.5')),
    LineItem('watermelon', 5, Decimal(5))
]
# 无需为每个新订单实例化新的促销对象——函数可直接复用
print(Order(joe, cart, fidelity_promo))        # <Order total: 42.00 due: 42.00>
print(Order(ann, cart, fidelity_promo))        # <Order total: 42.00 due: 39.90>

banana_cart = [
    LineItem('banana', 30, Decimal('.5')),
    LineItem('apple', 10, Decimal('1.5'))
]
print(Order(joe, banana_cart, bulk_item_promo)) # <Order total: 30.00 due: 28.50>

long_cart = [LineItem(str(item_code), 1, Decimal(1)) for item_code in range(10)]
print(Order(joe, long_cart, large_order_promo)) # <Order total: 10.00 due: 9.30>
print(Order(joe, cart, large_order_promo))      # <Order total: 42.00 due: 42.00>

自动选择最优策略

显式维护函数列表
promos = [fidelity_promo, bulk_item_promo, large_order_promo]

# 应用所有折扣并返回最大值
# 清晰可控 但是容易忘了更新
def best_promo(order: Order) -> Decimal:
    return max(promo(order) for promo in promos)
通过 globals() 自动发现
# 依赖命名约定（_promo 后缀）还需要排除 `best_promo 自身

promos = [
    promo for name, promo in globals().items()
    if name.endswith('_promo') and name != 'best_promo'
]

def best_promo(order: Order) -> Decimal:
    return max(promo(order) for promo in promos)
通过模块内省
# 不依赖命名，但假设模块中所有函数都是策略函数。
# 更灵活，但需注意模块污染风险
import inspect
import promotions  # 独立模块，包含所有策略函数

promos = [
    func for _, func in inspect.getmembers(promotions, inspect.isfunction)
]

def best_promo(order: Order) -> Decimal:
    return max(promo(order) for promo in promos)

装饰器增强的策略模式

策略模式的自动注册机制

在显示维护函数列表案例中，promos 列表需手动维护，容易因遗漏新策略函数而导致 best_promo 无法使用最新策略，形成隐蔽 bug。

通过定义 @promotion 装饰器，在函数定义时自动将其注册到全局策略列表中，消除手动维护负担。

from decimal import Decimal
from typing import Callable
from strategy import Order

# 类型别名：策略函数接受 Order，返回 Decimal
Promotion = Callable[[Order], Decimal]
promos: list[Promotion] = []  # 全局策略注册表

def promotion(promo: Promotion) -> Promotion:
    """注册装饰器：将策略函数加入 promos 列表"""
    promos.append(promo)
    return promo  # 原样返回函数，不改变其行为

def best_promo(order: Order) -> Decimal:
    """计算所有可用策略中的最大折扣"""
    return max(promo(order) for promo in promos)

# 使用 @promotion 装饰器自动注册
@promotion
def fidelity(order: Order) -> Decimal:
    if order.customer.fidelity >= 1000:
        return order.total() * Decimal('0.05')
    return Decimal(0)

@promotion
def bulk_item(order: Order) -> Decimal:
    discount = Decimal(0)
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * Decimal('0.1')
    return discount

@promotion
def large_order(order: Order) -> Decimal:
    distinct_items = {item.product for item in order.cart}
    if len(distinct_items) >= 10:
        return order.total() * Decimal('0.07')
    return Decimal(0)

使用注册表的优势在于无需特殊命名约定（如 _promo 后缀）。装饰器显式声明意图，@promotion 清晰表明该函数是策略。易于启用/禁用，注释掉装饰器即可临时移除策略。模块无关性，策略函数可定义在任意模块，只要应用了 @promotion。核心思想在于利用 Python 的装饰器机制实现自动注册，将“定义”与“发现”合二为一。

命令模式的函数式重构

经典命令模式

命令模式的目的是解耦调用者（Invoker） 与接收者（Receiver）。通过 Command 对象封装操作，调用者仅调用 command.execute()。

函数式替代方案

在 Python 中，函数本身就是可调用对象，天然可作为“命令”使用：调用者无需调用 command.execute()，直接调用 command() 即可。对于需要状态或组合的场景，可使用可调用类（实现 __call__ 方法）。

class MacroCommand:
    """一个可调用的命令容器，按顺序执行多个命令"""
    def __init__(self, commands):
        # 保存命令列表的副本，避免外部修改影响
        self.commands = list(commands)

    def __call__(self):
        # 当实例被调用时，依次执行所有命令
        for command in self.commands:
            command()

def open_file():
    print("Opening file...")

def save_file():
    print("Saving file...")

macro = MacroCommand([open_file, save_file])
macro()  # 输出: Opening file... \n Saving file...

# 如果需要支持撤销 可以使用闭包或者可调用类保存状态
def make_undoable(action, undo_action):
    def command():
        action()
        command.undo = undo_action  # 动态附加 undo 方法
    return command

每个 Python 可调用对象（函数、实现了 __call__ 的类实例等）本质上都实现了单一方法接口——即 __call__ 方法。 因此，对于无状态或简单状态的命令，函数足以替代单方法命令类；对于复杂需求，可调用对象 + 闭包提供了更灵活、更简洁的方案。

写代码犹如写文章: “大师级程序员把系统当故事来讲，而不是当做程序来写” | 如何架构设计复杂业务系统? 如何写复杂业务代码？
AI天才研究院
08-20 9979
写代码犹如写文章: “大师级程序员把系统当故事来讲，而不是当做程序来写” | 如何架构设计复杂业务系统? 如何写复杂业务代码？ Kotlin 开发者社区 “大师级程序员把系统当故事来讲，而不是当做程序来写” 写代码犹如写文章 好的代码应该如好文章一样表达思想，被人读懂。 中心思想: 突出明确 程序是开发者用编程语言写成的一本书，首...
python 头等对象之一，python 函数那些不一般的用法
热门推荐
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
10-10 2万+
本篇博客为你带来 python 函数相关知识点的回顾。 函数是 python 语言中一个非常重要的概念，并且是头等对象，可以把函数分配给变量，也可以将其作为参数传递给其它函数，当然作为其它函数的返回值也是可以的。 函数就是对象 函数是对象，所以可以将其赋值给一个变量 def func(): print("hello 橡皮擦") my_var = func # 注意没有括号 my_var() # 调用 函数是对象，所以可以出现在其它数据结构中，例如列表 函数可以作为列表的项。 def fun
Python笔记整理7: 第七章 函数
Sevieryang/FinTech/Statistics/Quant
02-12 508
问题： （1）代码冗余 (2) 代码的可维护性差 （3）没有模块化 （缺乏可读性） 函数定义： 可以重复使用，用来实现一个或者多个【功能】的代码段 函数的意义： 可以解决代码重复性问题，提高可维护性，提高程序的模块化程度，增加可读性 内建函数 在内置模块 print(“ddd”) input(“dd”) print(abs(-100,-200)) print(abs(“a”)) li=[1,2,...
Vulkan Programming Guide 第一章（1）
Blary的专栏
03-07 4792
内容 图片说明 表格说明 程序片段清单 关于本书 关于示例代码 错误纠正 致谢 关于作者第一章 Vulkan概述 1.1 介绍 1.2 实例，设备和队列 1.2.1 Vulkan实例 1.2.2 Vulkan物理设备 1.2.3 物理设备内存 1.2.4 设备队列 1.2.5 创建逻辑设备 1.3 对象类型和函
CleanCode读书笔记
weixin_42696160的博客
12-25 600
第一章 整洁代码 什么是整洁代码？ 整洁的代码应当代码正确，简单直接，应有单元测试和验收测试，清晰易读，只做一件事，尽量少的依赖关系； “如果每个例程都让你感到深含己意，那就是整洁代码”。 第二章 有意义的命名 2.1 名副其实 如果名称需要注释来补充，那就不算时名副其实。 2.2 避免误导 避免留下掩藏代码本意的错误线索；避免使用与本意相悖的词。 如：sco 不能做变量名，它是UNIX平台专有名称。 2.3 做有意义的区分 如果名称相异，其意思应该不同。 如：accountData
《代码整洁之道》读书笔记
Larry的博客
04-19 819
该文章转自：CodeInfo 目录 代码整洁之道 第一章 整洁代码 1.1-1.9 第二章 有意义的命名 2.1-2.6 2.7-2.18 第三章 函数 3.1-3.3 3.4-3.5 3.6-3.7 3.8-3.15 第四章 注释 4.1 - 4.3 4.4 - 4.5 第五章 格式 5.1 5.2 - 5.5 第六章 对象与数据结构 6.1 - 6.5 第七章 错误处理 7.1-7.2 7.3-7.10 第八章 边界 8.1-8.7 第九章 单元测试
Clean Code 总结
DreamArray的博客
02-23 818
自读Clean Code 总结为什么要看这本书第一章：整洁的意义整洁的代码具体体现在第二章：命名1.名副其实的命名2.避免误导3.做有意义的区分4.使用读得出来的名称5.使用可搜索的名称6.避免使用编码，消除前缀的需要7.类名+方法名+变量名8.别用双关语9.使用解决方案领域名称 还是 使用问题领域名称第三章：函数第四章：注释尽可能的用代码来阐述行为好注释:坏注释:第五章：格式垂直方向:横向格式:团队规则：第六章：对象和数据结构数据抽象：数据、对象和反对称性：得墨式耳律（LoD,迪米特法则）第七章：错误处
程序员应该如何写优雅代码，整洁代码，迭代优化 任重道远
hepei120的专栏
03-05 2821
如何让自己的代码更加优雅，如何让自己的代码越来越健壮，如何让自己跳出天天都在处理bug的怪圈。如何让自己过了2个月后看自己编辑的代码依然轻轻松松就知道它是干嘛的。 一个开发了50年的老程序员Bob大叔告诉你就得这么干。 内容整理自Robert C. Martin的《代码整洁之道》 第一章 整洁代码 1，整洁代码力求集中，每个函数、每个类和每个模块都全神贯注于一件事。 2，整洁代码简...
读书笔记——《clean code》
weixin_44051003的博客
12-23 302
第一章 《整洁代码》 1. 什么是整洁代码？ *代码逻辑直截了当，利于纠错 *尽量减少依赖关系，便于维护 *依据某种分层战略，处理异常 *性能调节至最优化，防止混乱 整洁的代码只做好一件事情！ 2. 简单代码特点： * 能通过所有代码 * 没有重复代码 * 体现系统全部设计理念 * 包括尽量少的实体，如类，方法，函数等 （无重复代码、只做一件事情、表达力、小规模抽象等） 第二章 《有意义的命名》 命名规则： 1.名副...
《架构整洁之道》读书笔记(上)
行走
06-02 561
代码整洁之道 读书笔记
Web-前端教程34 JS进阶：头等函数.zip
05-24
JavaScript中的头等函数是其语法特性的一个重要组成部分，这一特性赋予了函数在语言中的特殊地位，使其可以作为一等公民对待。在这个Web前端教程中，我们深入探讨JS进阶的头等函数概念及其应用。 首先，理解“头等...
第十章饭店消防设备及管理.pptx
10-07
在现代饭店经营中，消防安全是头等大事之一，关系到每个宾客和员工的生命安全，同时也关乎饭店的品牌形象与经济效益。饭店的建筑通常为高层或多层，内部设施复杂，人流量大，一旦发生火灾，后果不堪设想。火灾可能在...
进阶学习1：函数式编程FP——概念、头等函数、高阶函数、常用高阶函数模拟
JIZQAQ学习&踩坑笔记本
05-21 1350
一、什么是函数式编程 函数式编程Functional Programming（FP），是编程范式之一，其他编程范式还有面向过程编程、面向对象编程。 老师没有过多展开另外两个，于是课后我自己查了一下资料。 面向过程编程Procedure Oriented Programming（POP）： 分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。常见的有C语言。 //1.面向过程编程 //按照步骤一步一步来的 let num1 = 2 let num2 =
23种设计模式-16中介者模式
不开心就吃辣
12-03 831
本文介绍了中介者模式（Mediator Pattern），这是一种行为设计模式，通过中介对象封装一组对象的交互，减少对象间的直接依赖，提高代码的可扩展性和可维护性。文章分析了适用场景（对象交互复杂、逻辑分散、需提高复用性），详细说明了模式结构（中介者接口、具体中介者、同事类），并提供了Java实现的聊天应用示例代码。该模式类似于现实中的中介角色，能有效处理对象间交互，适用于需要解耦复杂对象关系的场景。
C++ 设计模式之观察者模式详细介绍
XiaoBinbest的博客
12-02 759
抽象接口是解耦的核心，确保被观察者和观察者仅依赖抽象，不依赖具体实现。
23种设计模式-17备忘录模式
不开心就吃辣
12-04 561
简化发起人实体类(Originator）职责，隔离状态存储与获取，实现了信息的封装，客户端 无需关心状态的保存细节；提供回滚功能消耗资源：如果需要保存的状态过多 Memento 类过大时，每一次保存都会消耗很多内存。
Pimpl（Pointer to Implementation）设计模式详解
最新发布
2301_80355452的博客
12-06 767
cpp// 传统方式 - MyClass.hpublic:MyClass();private:// 私有数据成员// 需要包含<vector>// 需要包含<map>// 需要包含第三方头文件// ... 更多实现细节问题编译依赖：任何包含MyClass.h的文件都会间接包含所有依赖的头文件编译时间长：修改私有成员会导致所有包含此头文件的文件重新编译暴露实现细节：用户能看到私有成员，违反了封装原则。
从装饰者到桥接再到工厂：模式组合的艺术
m0_72755177的博客
12-02 814
装饰者就像套娃，每个娃娃外表看起来都一样，但大娃娃里面套着小娃娃。：桥接模式让两个维度"门当户对、平等合作"，而不是一个依附另一个。// 正确的：“目前有3种配料，用简单方案，等真有10种时再重构”有些维度应该平等相处。：设计一个游戏角色系统，有职业（战士、法师）和装备（剑、法杖）传统继承需要：红圆、蓝圆、红方、蓝方 → 4个类。装备不是"装饰"职业，装备可以独立存在。装饰者模式说："别急，我们来玩俄罗斯套娃！// 第二版：发现需要加配料 → 引入装饰者。5种配料（糖、奶、奶油、焦糖、肉桂）
设计模式 - 命令模式
xiaohaha123258的博客
12-05 668
四大角色Command（命令）：定义执行操作的接口ConcreteCommand（具体命令）：绑定接收者和动作Invoker（调用者）：请求的发送者Receiver（接收者）：知道如何执行操作三大优势✅解耦：调用者与接收者完全独立✅可扩展：新命令很容易添加✅支持高级功能：撤销、重做、队列、日志等需要将操作参数化的场景需要支持撤销/重做、事务处理的场景。
JavaScript头等函数深入教程
因此，本教程也会简要介绍这些新特性如何与头等函数结合使用，提高代码的现代性和性能。 总而言之，JavaScript中的头等函数是一个重要的编程概念，它不仅体现了函数式编程的优势，也是实现JavaScript编程灵活性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值