Python
14 函数进阶:lambda、高阶函数与装饰器
函数是对象、lambda、闭包与 nonlocal、看懂 `@tool` 这类装饰器
- Python
- 进阶
目标:把「函数是一种数据——可以存、可以传、可以被包一层再返回」这条主线打通,lambda、高阶函数、闭包、装饰器都从这个视角自然长出来;学完能读懂并写出
key=lambda、f(*args, **kwargs)、@wraps这类真实代码惯用法。 与 LangChain 的关系:LCEL 链里 lambda 是传函数的日常语法;Agent 的工具定义@tool就是一个「带参数的装饰器」——看懂装饰器 = 看懂 LangChain 工具定义。
1. 为什么需要:入门课教的函数,和真实代码里的函数不是一回事
第 8 章教的函数模型是「定义 → 传参 → 调用 → 返回」,函数始终是被执行的东西。看一段真实项目代码(摘编自 ../langchain-book-python/11-FunctionCalling.md 的工具执行环节,result 等为上文变量):
functions = {"get_current_weather": get_current_weather} # 函数存进字典
for tool_call in result.choices[0].message.tool_calls:
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
output = functions[name](**args) # 从字典取出函数,再解包调用
再看两行高频惯用法:
results.sort(key=lambda r: r["score"], reverse=True) # 函数当参数传给 sort
@tool # 函数被"包"了一层再顶原名
def search(query: str) -> str:
"""搜索网页"""
这五分钟看到的写法——函数存字典、(**args) 解包调用、key=lambda、@tool——入门课一个都没讲,但真实代码里遍地都是。本章就补这个视角:函数是对象,像数字、字符串一样可以被传递和加工。
2. 地基:函数是对象
机制:def 是一条可执行的语句。运行到它时,Python 创建一个函数对象(内含字节码、名字 __name__、文档 __doc__),再把函数名绑定到这个对象上。函数名只是贴在对象上的标签,() 才是”执行”动作——say_hi 是对象本身,say_hi() 是调用。下面四个小例层层递进。
例 1:赋给变量(不加括号,传递的是对象不是调用):
def say_hi():
return "hi"
print(type(say_hi)) # → <class 'function'>
print(say_hi.__name__) # → say_hi
another = say_hi # 对象换个标签,没有执行
print(another()) # → hi
print(say_hi is another) # → True:两个名字,同一个对象
例 2:存进字典——策略表,替代 if/elif 分支:
def shout(text):
return text.upper() + "!"
def whisper(text):
return text.lower() + "..."
styles = {"loud": shout, "quiet": whisper} # 存函数对象,没有括号
print(styles["loud"]("hello")) # → HELLO!
新增一种风格只加一行字典;新增一种 if 分支要改函数体。这就是第 1 节 functions = {...} 的原理。
例 3:当参数——接收函数作为参数的函数叫高阶函数:
def shout(text):
return text.upper() + "!"
def apply_twice(func, value): # func 是个函数对象
return func(func(value)) # 拿到什么就调用什么
print(apply_twice(shout, "go")) # → GO!!
sorted 的 key= 正是这一机制:你把”怎么比较”作为一个函数交出去,sorted 负责在合适的时机调用它。
例 4:当返回值——函数可以生产函数:
def make_greeter(name):
def greeter():
return f"你好,{name}"
return greeter # 返回函数本身,注意没有括号
greet_hal = make_greeter("Hal")
print(greet_hal()) # → 你好,Hal
greeter 记住了出生时的 name——这就是闭包,第 6 节细讲。
3. *args 与 **kwargs:参数的打包与解包
星号有两个方向,初学时最容易只见过一个。
定义端:打包——把多余的实参收进一个容器:
def pack(*args, **kwargs):
print("args =", args, type(args).__name__)
print("kwargs =", kwargs, type(kwargs).__name__)
pack(1, 2, 3, x=4, y=5)
# → args = (1, 2, 3) tuple
# → kwargs = {'x': 4, 'y': 5} dict
调用端:解包——把容器拆开、逐个传入:
def add3(a, b, c):
return a + b + c
nums = [1, 2, 3]
info = {"a": 10, "b": 20, "c": 30}
print(add3(*nums)) # → 6 等价于 add3(1, 2, 3)
print(add3(**info)) # → 60 等价于 add3(a=10, b=20, c=30)
| 方向 | 位置 | 星号写在 | 效果 |
|---|---|---|---|
| 打包 | 函数定义 | 形参 *args | 多余的位置实参收进 tuple |
| 打包 | 函数定义 | 形参 **kwargs | 多余的关键字实参收进 dict |
| 解包 | 函数调用 | 实参 f(*lst) | 序列拆开,按位置逐个传入 |
| 解包 | 函数调用 | 实参 f(**dct) | 字典拆开,按关键字逐个传入 |
两个方向组合出真实代码里的万能转发签名 def wrapper(*args, **kwargs):无论被包装的函数长什么样,参数原样接住、原样转交。第 1 节的 functions[name](**args) 就是”字典取函数 + 解包调用”一行完成。
解包还能用在字面量合并上(高频写法):
a, b = [1, 2], [3, 4]
print([*a, *b]) # → [1, 2, 3, 4]
print({**{"x": 1}, "y": 2}) # → {'x': 1, 'y': 2}
完整签名顺序:把所有参数形态放进一个签名,Python 按位置严格解析成五段:
def f(a, /, b, *args, c, **kwargs):
print(f"a={a}, b={b}, args={args}, c={c}, kwargs={kwargs}")
f(1, 2, 3, 4, c=5, x=6, y=7)
# → a=1, b=2, args=(3, 4), c=5, kwargs={'x': 6, 'y': 7}
| 段 | 位置 | 身份 | 调用要求 |
|---|---|---|---|
a | / 之前 | 仅位置参数 | 只能 f(1),不能 f(a=1) |
b | / 与 *args 之间 | 位置或关键字 | 两种都行 |
args | * 处 | 收集剩余位置参数(tuple) | 可不传 |
c | *args 之后 | 仅关键字参数 | 必须写 c=... |
kwargs | ** 处 | 收集剩余关键字参数(dict) | 可不传 |
两个报错反例(在解释器里试):
>>> f(1, 2, 3)
TypeError: f() missing 1 required keyword-only argument: 'c'
>>> f(a=1, b=2, c=3)
TypeError: f() missing 1 required positional argument: 'a'
第二个最反直觉:a=1 并没有给 a,而是掉进了 kwargs——a 是仅位置参数,关键字形式的 a=1 只能被 **kwargs 收走。什么时候用:/ 用于不希望调用方依赖参数名的稳定接口(内置 len(obj) 就是);仅关键字参数用于强制调用方写明含义(connect(host, port, timeout=30) 比 connect(h, p, 30) 可读)。
4. lambda:一次性小函数
语法:lambda 参数: 表达式——表达式的值就是返回值,它就是个匿名的函数对象。限制:冒号后只能是单个表达式,不能有语句:
# ❌ 语法错误:lambda 里不能赋值
# total = lambda acc, x: acc += x
# 要多步逻辑,用 def:
def add(acc, x):
acc += x
return acc
最适用的场景是 key=:作为参数当场传入、只用一次。
students = [("小明", 88), ("小红", 95), ("小刚", 73)]
print(max(students, key=lambda s: s[1])) # → ('小红', 95)
print(sorted(students, key=lambda s: s[1], reverse=True))
# → [('小红', 95), ('小明', 88), ('小刚', 73)]
scores = {"小明": 88, "小红": 95, "小刚": 73}
print(sorted(scores.items(), key=lambda kv: kv[1], reverse=True))
# → [('小红', 95), ('小明', 88), ('小刚', 73)]
机制:max/sorted 不直接比较元素本身,而是对每个元素调用 key 函数、用返回值当”比较用的影子”——原元素不动,排序按影子来。所以 key=len 按长度、key=lambda s: s[1] 按第二项。
什么时候该换 def:
| 情况 | 用什么 |
|---|---|
一行表达式、只用一次、当场传入 key= | lambda |
| 需要复用、需要名字 | def |
| 需要多步逻辑、赋值、循环、异常处理 | def(lambda 写不了) |
| 复杂签名(默认值、仅关键字参数) | def |
原则:f = lambda x: ... 这种”给 lambda 起名”的写法能跑但被 PEP 8 劝退——要起名就直接 def。
5. map / filter / reduce:认识它们,但写推导式
nums = [1, 2, 3, 4, 5, 6]
print(list(map(str, nums))) # → ['1', '2', '3', '4', '5', '6']
print(list(filter(lambda n: n % 2 == 0, nums))) # → [2, 4, 6]
map(函数, 可迭代) 逐个变换,filter(函数, 可迭代) 按条件筛选;它们返回的是迭代器(第 16 章),要 list() 收集才能看到内容。与推导式对照:
[str(n) for n in nums] # 同 map(str, nums)
[n for n in nums if n % 2 == 0] # 同 filter(...)
| map / filter | 列表推导式 | |
|---|---|---|
| 可读性 | 组合嵌套后急剧下降 | 接近自然语言,可加 if/条件表达式 |
| 复用已有函数 | map(str, nums) 很顺手 | [str(n) for n in nums] 略啰嗦 |
| 惰性求值 | 是(省内存) | 生成器表达式 (x for x in ...) 同样支持 |
结论:读代码必须认识 map/filter(存量代码、库源码、面试题大量存在);写代码推荐推导式。reduce 认识即可——把序列”折叠”成一个值,Python 3 起移出内置、收进 functools(因为它总能被更直白的循环替代):
from functools import reduce
from operator import mul
print(reduce(mul, [1, 2, 3, 4, 5], 1)) # → 120(连乘,1 是初始值)
6. 闭包:函数记住出生地
机制:内层函数引用了外层函数的变量,外层函数返回后这些变量本该销毁——但只要内层函数还引用着,Python 就把它们连同保留。函数对象身上的 __closure__ 属性,装着它引用的外部变量”盒子”。
函数工厂——一次出厂、终身记忆:
def make_multiplier(n):
def multiply(x):
return x * n # 引用外层的 n
return multiply
double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5), triple(5)) # → 10 15
每次调用 make_multiplier 都产生独立的 n,double 与 triple 互不干扰。
late-binding 陷阱——循环里建闭包的经典坑,逐行看:
funcs = [lambda: i for i in range(3)] # 第 1 行:造 3 个函数,意图各返回自己的 i
results = [g() for g in funcs] # 第 2 行:调用它们
print(results) # 第 3 行:→ [2, 2, 2]!期望 [0, 1, 2]
- 第 1 行循环 3 轮,每轮创建一个 lambda。lambda 身上没存
i的值,只存了”到外层找i”的引用——这就是晚绑定(late binding):用到i的那一刻才去查。 - 循环结束,
i定格在最终值 2(这个i是整个推导式共享的一个变量,不是三个)。 - 第 2 行调用
g()时才去查i,三个函数查的是同一个盒子,里面都是 2。
修复:用默认参数在创建时拍快照(默认参数在函数定义时求值):
funcs = [lambda i=i: i for i in range(3)] # i=i:右边取当前值作默认值
print([g() for g in funcs]) # → [0, 1, 2]
或者用工厂函数,每轮调用都新建局部变量:
def make_printer(i):
def printer():
return i # 这里的 i 是本轮调用的局部变量
return printer
funcs = [make_printer(i) for i in range(3)]
print([g() for g in funcs]) # → [0, 1, 2]
口诀:闭包记住的是变量,不是值。
nonlocal:让闭包能写外层变量
前面两个闭包都只是读外层的变量。一旦想赋值,第 8 章 4.1 的规则立刻生效:函数里对名字赋值 = 创建新的局部变量。计数器闭包正好摔在这个坑上:
def make_counter():
count = 0
def counter():
count += 1 # ❌ UnboundLocalError:count 被当成 counter 自己的局部变量
return count
return counter
修法是闭包版的 global——nonlocal:声明「这个名字指最近一层外层函数的同名变量」:
def make_counter():
count = 0
def counter():
nonlocal count # 指向外层 make_counter 的那个 count
count += 1
return count
return counter
c1 = make_counter()
c2 = make_counter()
print(c1(), c1(), c1()) # → 1 2 3
print(c2()) # → 1:各数各的,互不干扰
这才是闭包的完全体:函数 + 一块只有它看得见、还能改写的私有变量。每次工厂调用都新造一块——对照前面的函数工厂:double/triple 记住的 n 只能读,这里的 count 还能更新。
global 与 nonlocal 一张表分清:
| 声明 | 改的是谁 | 外层没有这个名字时 |
|---|---|---|
global x | 模块顶层的 x(第 8 章 4.2) | 不报错:赋值会在顶层新建 x |
nonlocal x | 最近一层外层函数的 x(跳过全局) | SyntaxError:还没运行、编译期就拒绝 |
两个补充。一,nonlocal 是语句,lambda 里写不了——所以前面 late-binding 陷阱没法用 nonlocal 修,只能快照或工厂函数。二,真实代码里 nonlocal 的高频场景就是「带状态的装饰器」:wrapper 里用 nonlocal 记调用次数、限流窗口——状态只有一两个变量时它最轻;状态一多就该换成类(第 15 章),实例属性是更体面的「对象自带可变状态」。
7. 装饰器:四步推导
第 1 步,函数是对象(第 2 节):可以被赋值、传递。 第 2 步,函数能当参数和返回值(第 2、6 节):于是可以写一个”接收函数、返回新函数”的高阶函数。 第 3 步,手写 wrapper:
import functools
import time
def timer(func):
@functools.wraps(func) # 保留原函数元信息,见 7.6
def wrapper(*args, **kwargs): # 万能签名:原样接住任意参数
start = time.perf_counter()
result = func(*args, **kwargs) # 原样转交
print(f"{func.__name__} 耗时 {time.perf_counter() - start:.4f}s")
return result # 原样返回
return wrapper
def slow_sum(n):
time.sleep(0.1)
return sum(range(n))
slow_sum = timer(slow_sum) # 手动包装:slow_sum 换指向新函数
slow_sum(10_000)
# → slow_sum 耗时 0.1005s
第 4 步,@ 语法糖:@timer 完全等价于 slow_sum = timer(slow_sum),只是把”定义完立刻包装”写成声明:
@timer
def slow_sum(n):
time.sleep(0.1)
return sum(range(n))
所以 @ 没有引入新语义——装饰器 = 「接收函数 → 返回新函数」的高阶函数 + @ 帮你自动做的那次赋值。
7.5 带参数的装饰器:三层函数
真实代码里还有 @lru_cache(maxsize=None)、@tool(return_direct=True) 这种带括号的。原因:@ 后面必须跟”接收函数的函数”,而 repeat(3) 要先执行、算出这个装饰器。于是最外层先收配置,返回装饰器,装饰器再收函数、返回 wrapper——三层:
import functools
def repeat(times): # 第 1 层:收配置,返回真正的装饰器
def decorator(func): # 第 2 层:收函数,返回包装
@functools.wraps(func)
def wrapper(*args, **kwargs): # 第 3 层:实际执行
result = None
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3) # 等价于 shout = repeat(3)(shout),连续两次调用
def shout(text):
print(text.upper() + "!")
shout("go")
# → GO!
# → GO!
# → GO!
@repeat(3) 与 @repeat 差一个括号、差一整层函数,是最容易看混的两种形态。
7.6 @wraps 为什么必要
装饰后外界拿到的其实是 wrapper。没有 @wraps 时,原函数的”身份证”全被 wrapper 顶掉:
def bad_deco(func):
def wrapper(*args, **kwargs): # ❌ 忘了 @functools.wraps(func)
return func(*args, **kwargs)
return wrapper
@bad_deco
def greet():
"""打招呼"""
return "hi"
print(greet.__name__) # → wrapper(名字丢了)
print(greet.__doc__) # → None(文档丢了)
影响不止是好看:日志和报错里全是 wrapper 无法定位问题;help(greet) 显示错误信息;更要命的是依赖自省读函数信息的框架会被骗——LangChain 的 @tool 正是靠读函数名和 docstring 生成工具描述的(见第 9 节)。@functools.wraps(func) 把原函数的 __name__、__doc__ 等元信息复制到 wrapper 上,一行成本保住身份。
7.7 functools 两件套:lru_cache 与 partial
lru_cache:记住”参数 → 结果”,同参数再调用直接查表。递归 fib 是教科书案例——朴素 fib(32) 要发起 7,049,155 次函数调用(本机实测约 0.3 秒;调用次数是确定的,与机器无关),fib(40) 约 3.3 亿次基本跑不完。加一行装饰器:
import functools
@functools.lru_cache(maxsize=None) # maxsize=None:缓存不限容量
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
print(len(str(fib(300)))) # → 63 位大数,瞬间完成(本机实测约 0.0002 秒)
print(fib.cache_info()) # → CacheInfo(hits=298, misses=301, maxsize=None, currsize=301)
注意边界:参数必须可哈希(传 list 会 TypeError,改用 tuple);只适合纯函数——同样输入永远同样输出,含随机数、读文件、读当前时间的函数不能缓存。
partial:固定一个函数的部分参数,生成新函数:
import functools
int2 = functools.partial(int, base=2) # 预设了 base=2 的 int
print(int2("1010")) # → 10,等价于 int("1010", base=2)
它和 lambda s: int(s, base=2) 能干同一件事,但 partial 显式保留”原函数 + 固定参数”的信息,注册回调、减少小函数时更清晰。
7.8 带状态的装饰器:nonlocal 落地
第 6 节末尾说过,nonlocal 的高频场景就是带状态的装饰器——现在兑现。统计一个函数被调了多少次:
import functools
def count_calls(func):
total = 0 # 装饰器层的私有变量
@functools.wraps(func)
def wrapper(*args, **kwargs):
nonlocal total # wrapper 要改装饰器层的 total
total += 1
print(f"{func.__name__} 第 {total} 次被调用")
return func(*args, **kwargs)
return wrapper
@count_calls
def upload(path):
print(f"上传 {path}")
upload("a.jpg")
# → upload 第 1 次被调用
# → 上传 a.jpg
upload("b.jpg")
# → upload 第 2 次被调用
# → 上传 b.jpg
对照 7.5 的三层结构:这里少了配置层,剩两层,多出的关键是 total——它在被装饰的那一刻创建,活在装饰器层,调用之间不丢、外界又摸不到。限流计数、重试次数、缓存大小都是同一形态。状态再往上堆,就换用实现了 __call__ 的类来写装饰器(第 15 章),实例属性是更体面的状态容器。
7.9 多个装饰器叠放:洋葱模型
真实代码经常一个函数上挂好几个装饰器:
@a
@b
def f(): ...
完全等价于 f = a(b(f))——应用顺序自下而上:靠近 def 的 b 先包装函数,a 再包在外面。执行时自然从最外层进、最外层出,像剥洋葱。眼见为实(用 7.5 的带参数装饰器给两层贴上名字):
import functools
def deco(name):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"[{name}] 前")
result = func(*args, **kwargs)
print(f"[{name}] 后")
return result
return wrapper
return decorator
@deco("外")
@deco("内")
def hello():
print("hello 执行")
hello()
[外] 前
[内] 前
hello 执行
[内] 后
[外] 后
你后面会遇到的叠放都不是随便排的:pydantic v2 的 @field_validator(...) 上、@classmethod 下(顺序是约定的一部分,第 21 章照写);ABC 的 @property 上、@abstractmethod 下(第 15 章)。叠错顺序的典型症状是”装饰器拿到的东西不是你以为的那种”——排查时先按 f = a(b(f)) 展开看每层拿到什么。
最后把视角拉高一层:装饰器吃下去的不只是函数。类体里的方法定义同样是函数——第 15 章的 @property、@classmethod、@staticmethod 就是三个内置装饰器;@dataclass 干脆吃下整个类、返回加工后的类再绑回原名(第 15 章第 8 节)。机制从头到尾没变:@ 后面的东西接收下方的定义,交回一个成品,绑回原名。
8. 常见坑
- 忘了
@wraps(7.6):症状是日志里全是wrapper、help()失效、框架读不到 docstring。修法:wrapper 上一行加@functools.wraps(func)。 - lambda 里赋值(第 4 节):
SyntaxError: cannot assign to lambda。lambda 只能写单个表达式;要累加、循环、异常处理就用 def 或 reduce。 - 装饰器执行时机:装饰发生在
def执行时(通常是 import 时),不是函数调用时:
def deco(func):
print(f"deco 正在包装 {func.__name__}") # 这行在 def 时就执行
return func
@deco
def hello():
print("hello 执行")
print("--- 模块加载完 ---")
hello()
deco 正在包装 hello
--- 模块加载完 ---
hello 执行
推论一:装饰器里的非函数代码(打印、注册动作)会在 import 时跑一遍。推论二:带参装饰器忘写括号(@repeat 而非 @repeat(3))不报错但行为完全错位——函数被当成配置传进了第 1 层,调用时才炸出难以理解的 TypeError。
- 循环里建闭包(第 6 节):late-binding,记得
lambda i=i: i拍快照。 - 闭包里改外层变量忘了
nonlocal(第 6 节):UnboundLocalError——加一行nonlocal count。注意 lambda 里写不了 nonlocal(它是语句),循环建闭包的坑只能用快照或工厂函数修。 - 装饰器叠放记反顺序(7.9):应用自下而上(
f = a(b(f)))、执行从最外层进。框架里叠放顺序常是硬约定(pydantic v2 的@classmethod必须在@field_validator之下),照文档写。
9. 在 LangChain 里的样子
摘编自 ../langchain-book-python/12-Agent系统.md(1.x 定义 Agent 工具的标准写法):
from typing import Annotated
from langchain.tools import tool
@tool
def get_exchange_rate(
base: Annotated[str, "基准货币代码,如 USD"],
target: Annotated[str, "目标货币代码,如 CNY"],
) -> str:
"""查询两种货币之间的当前汇率"""
table = {"USD:CNY": 7.24, "USD:EUR": 0.92}
rate = table.get(f"{base}:{target}")
if rate is not None:
return f"1 {base} = {rate} {target}"
return f"没有 {base} 到 {target} 的汇率数据"
逐行拆开,全是本章机制:
@tool:7.5 的「带参数的装饰器」形态——不带括号时是普通装饰器;带括号时先吃配置再返回装饰器。装饰后get_exchange_rate已不是原函数,而是一个 BaseTool 对象——名字没变、对象被换掉,正是第 4 步”自动重新赋值”。它还能照样get_exchange_rate(...)调用,是因为 BaseTool 实现了__call__(第 15 章 5.4)——「对象冒充函数」和「用类写带状态的装饰器」是同一个机制,两章在此接壤。- 函数名
get_exchange_rate→ 工具的 name,LLM 看到并以此发起调用(所以建议 snake_case)。 - docstring
"""查询两种货币之间的当前汇率"""→ 工具的 description,是 LLM 判断”是否调用、何时调用”的唯一信息来源——这就是 7.6 强调元信息不能丢的现实理由。 - 参数注解
Annotated[str, "基准货币代码,如 USD"]→ 自动生成参数 schema(类型来自str,描述来自 Annotated 第二项),LLM 据此构造调用参数。类型注解见 13-类型注解实战,Annotated 与 pydantic 见 21-pydantic数据建模。 - 函数体原样执行:装饰器没有改你的逻辑,只是包了一层”对外自我描述”的壳。
带参数的真实形态(摘编自同一章,工具结果直接作为 agent 最终输出):
@tool(return_direct=True) # 工具结果直接作为 agent 最终输出,短路 agent 循环
def retrieve_qiu(query: Annotated[str, "信息完整的独立问题"]) -> str:
"""获取小说《球状闪电》相关问题的答案,命中即直接返回"""
return retrieve_docs(query)
对照 7.5:@tool(return_direct=True) 展开就是 retrieve_qiu = tool(return_direct=True)(retrieve_qiu)——两次调用、三层函数。再回看第 1 节的 functions[name](**args)(11-FunctionCalling.md 的闭环):字典当工具注册表、**args 把 LLM 返回的 JSON 参数解包成关键字参数——函数进字典、出字典、被解包调用,第 2、3 节的机制在一行里各就各位。
结论:LangChain 里「定义一个工具」=「写一个普通函数 + 用装饰器声明它的对外描述」。看懂装饰器 = 看懂工具定义;顺着同一机制,@staticmethod、@app.route、@pytest.fixture 也都能读懂。系统对照见 22-读懂LangChain:语法桥。
小练习
- 写
calc(op, a, b):内部用字典{"add": add, "sub": sub, "mul": mul}查表调用(函数是对象)。 - 给
sales = [{"name": "A", "amount": 300}, {"name": "B", "amount": 950}, {"name": "C", "amount": 120}],用sorted+ lambda 按 amount 降序排列,再用max找出单笔最高。 - 写带参数的装饰器
@repeat(times):让被装饰函数执行 times 次并返回最后一次结果;用__name__验证元信息没丢。 - 写闭包工厂
make_prefixer(prefix):返回的函数把prefix + " " + text加在文本前;验证两个出厂实例互不影响。 - 写
make_averager():返回一个函数,每次传入一个数,返回截至目前所有数的平均(用 nonlocal 记住 total 和 n)。 - 改造 7.8 的
count_calls:不打印,把当前次数挂到wrapper.calls属性上(提示:函数是对象,第 2 节,可以随便挂属性),使得upload.calls随时可读、没调用时是 0。
练习答案
# 练习 1
def add(a, b):
return a + b
def sub(a, b):
return a - b
def mul(a, b):
return a * b
def calc(op, a, b):
ops = {"add": add, "sub": sub, "mul": mul} # 存函数对象
return ops[op](a, b) # 查表 + 调用
print(calc("mul", 6, 7)) # → 42
# 练习 2
sales = [
{"name": "A", "amount": 300},
{"name": "B", "amount": 950},
{"name": "C", "amount": 120},
]
print(sorted(sales, key=lambda s: s["amount"], reverse=True))
# → [{'name': 'B', ...}, {'name': 'A', ...}, {'name': 'C', ...}]
print(max(sales, key=lambda s: s["amount"])) # → {'name': 'B', 'amount': 950}
# 练习 3
import functools
def repeat(times):
def decorator(func):
@functools.wraps(func) # 不加这行,hello.__name__ 会变 wrapper
def wrapper(*args, **kwargs):
result = None
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3)
def hello():
print("hi")
hello() # 打印 3 行 hi
print(hello.__name__) # → hello
# 练习 4
def make_prefixer(prefix):
def prefixer(text):
return f"{prefix} {text}"
return prefixer
warn = make_prefixer("[警告]")
info = make_prefixer("[信息]")
print(warn("磁盘快满了")) # → [警告] 磁盘快满了
print(info("已备份")) # → [信息] 已备份
# 练习 5
def make_averager():
total = 0
n = 0
def averager(x):
nonlocal total, n # 一个 nonlocal 可以同时声明多个名字
total += x
n += 1
return total / n
return averager
avg = make_averager()
print(avg(80), avg(90), avg(70)) # → 80.0 85.0 80.0
# 练习 6
import functools
def count_calls(func):
total = 0
@functools.wraps(func)
def wrapper(*args, **kwargs):
nonlocal total
total += 1
wrapper.calls = total # 函数是对象,可以挂属性
return func(*args, **kwargs)
wrapper.calls = 0 # 没调用过也能读
return wrapper
@count_calls
def upload(path):
return f"上传 {path}"
print(upload.calls) # → 0
upload("a.jpg")
upload("b.jpg")
print(upload.calls) # → 2