跳转到主要内容

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. 第 1 行循环 3 轮,每轮创建一个 lambda。lambda 身上没存 i 的值,只存了”到外层找 i”的引用——这就是晚绑定(late binding):用到 i 的那一刻才去查。
  2. 循环结束,i 定格在最终值 2(这个 i 是整个推导式共享的一个变量,不是三个)。
  3. 第 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:语法桥。

小练习

  1. 写 calc(op, a, b):内部用字典 {"add": add, "sub": sub, "mul": mul} 查表调用(函数是对象)。
  2. 给 sales = [{"name": "A", "amount": 300}, {"name": "B", "amount": 950}, {"name": "C", "amount": 120}],用 sorted + lambda 按 amount 降序排列,再用 max 找出单笔最高。
  3. 写带参数的装饰器 @repeat(times):让被装饰函数执行 times 次并返回最后一次结果;用 __name__ 验证元信息没丢。
  4. 写闭包工厂 make_prefixer(prefix):返回的函数把 prefix + " " + text 加在文本前;验证两个出厂实例互不影响。
  5. 写 make_averager():返回一个函数,每次传入一个数,返回截至目前所有数的平均(用 nonlocal 记住 total 和 n)。
  6. 改造 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