04.7.2 函数、闭包与装饰器
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
- 参数传递、参数种类与解包
- 作用域 LEGB、global 与 nonlocal
- 闭包、延迟绑定与
__closure__ - 装饰器原理、带参装饰器、类装饰器
- functools 常用工具:wraps、lru_cache、partial、singledispatch
- 递归、高阶函数与函数内省
04.7.2-001 Python 的参数传递到底是值传递还是引用传递?
一句话结论
都不是,准确说法是“对象引用按值传递”(call by object reference / call by sharing):实参的引用被复制一份给形参,形参与实参指向同一对象;形参重新绑定不影响实参,但通过形参修改可变对象内容会被调用方看到。
概念解释
- 对不可变对象(int、str、tuple),函数内“修改”必然产生新对象,调用方看不到变化,表现得像值传递。
- 对可变对象(list、dict),函数内
append、d[k] = v会直接改到原对象,表现得像引用传递。
原理流程
- 调用时把实参对象的引用复制一份绑定到形参,形参与实参指向同一个对象。
- 形参重新绑定到新对象,只改局部名字,不写回实参变量。
- 通过形参原地修改可变对象内容,调用方持有的引用能观察到变化。
代码或图示
def f(x, lst):
x = 100 # 只重绑定形参,外部不变
lst.append(1) # 原地修改,外部可见
a, b = 1, []
f(a, b)
print(a, b) # 1 [1]
常见误区
- 切片赋值、
+=对可变参数的原地修改最容易引发“函数偷偷改了入参”的 bug。 - 想避免副作用:进入函数先拷贝(
list(x)、copy.deepcopy)或改用不可变数据;想返回修改结果应显式return新对象,别依赖原地改。
追问
- 为什么
x = 100不影响调用方?答:形参只是本地名字,重新绑定换的是名字指向,不写回实参的引用。 - 为什么说“Python 没有引用传递”?答:引用传递要求形参是实参的别名,改形参本身能影响实参;这里改的是形参绑定,不是实参变量。
- 怎么在函数里“安全地改 list”?答:返回新列表(
return lst + [x])或在文档中明确声明原地修改语义。
04.7.2-002 *args 和 **kwargs 怎么用?参数顺序有什么规则?
一句话结论
*args 收集多余位置参数为 tuple,**kwargs 收集多余关键字参数为 dict;定义时顺序固定为「位置参数 → 默认参数 → *args → 仅关键字参数 → **kwargs」。调用时 *seq 解包位置、**mapping 解包关键字。
概念解释
*args之后、**kwargs之前的参数是“仅关键字参数”,必须按名字传。- 命名约定:
args/kwargs只是习惯,真正语义由位置决定。
原理流程
- 定义时按位置参数、默认参数、
*args、仅关键字参数、**kwargs的顺序解析。 - 调用时
*seq把序列展开为位置参数,**mapping把字典展开为关键字参数。 f(*a, *b)可多次解包(3.5+),f(**d1, **d2)后者覆盖同名键;解包数量必须匹配形参,否则 TypeError;**解包的键必须是字符串。
代码或图示
def f(a, b=2, *args, sep="-", **kwargs):
print(a, b, args, sep, kwargs)
f(1, 3, 4, 5, sep="|", extra=True)
# 1 3 (4, 5) | {'extra': True}
常见误区
- 装饰器透传参数时遗漏
**kwargs,导致关键字参数被丢弃。 **解包的键不是字符串或不是合法标识符,直接 TypeError。
追问
- 为什么
*args之后还能有参数?答:它们自动变成仅关键字参数,避免调用方按位置误传。 **kwargs能接收非字符串键吗?答:不能,关键字参数名必须是合法标识符,f(**{1: 2})直接 TypeError。- 装饰器里如何原样透传?答:
def wrapper(*args, **kwargs): return func(*args, **kwargs),并加functools.wraps。
04.7.2-003 仅位置参数 / 和仅关键字参数 * 有什么用?
一句话结论
/ 之前的参数只能按位置传(3.8+),* 之后的参数只能按名字传。前者用于“参数名是内部实现、不该暴露”的 API(如内建函数),后者用于强制可读性、避免布尔参数歧义。
概念解释
def f(a, b, /, c, *, d):a、b 仅位置;c 位置或关键字;d 仅关键字。- 内建函数大量使用仅位置参数(如
len(obj)、dict.get(key, default)),避免历史参数名绑死。
原理流程
/声明其左侧参数不参与按名传参,调用方只能按位置传入。*声明其右侧参数必须按关键字传入,调用点强制写参数名。- 用
/后重命名参数不算破坏兼容;用*后新增参数更安全,不会与位置调用冲突。
代码或图示
def connect(host, port, /, *, timeout=5, retry=2):
...
connect("db", 5432, timeout=1) # OK
# connect(host="db", port=5432) # TypeError,host/port 仅位置
常见误区
- 对外 API 用仅位置参数,导致调用方无法按名阅读参数含义。
- 布尔开关参数允许按位置传,出现
f(True, False)这种猜谜调用。
追问
- 为什么内建函数要限制参数名?答:C 实现层没有 Python 参数名,限制后行为统一且未来可改。
- 仅关键字参数能提升可维护性吗?答:能,调用点一眼看出含义,避免
f(True, False)这种猜谜。 - 团队项目里怎么用?答:对外 API 固定用
*隔离开关参数;内部实现用/隐藏易变细节。
04.7.2-004 什么是 LEGB 作用域规则?
一句话结论
名字查找顺序:Local(当前函数)→ Enclosing(外层函数)→ Global(模块)→ Builtin(内建)。找不到抛 NameError。赋值默认创建 Local 名字,除非声明 global/nonlocal。
概念解释
- 函数内部读取变量时按 LEGB 逐层找,找到即停;不会继续向上层找同名。
- 模块级名字即 Global,
globals()可查看。
原理流程
- 读取名字时先在当前函数局部命名空间查找。
- 未命中依次向外层函数、模块全局、内建命名空间查找。
- 赋值语句让名字成为 Local(编译期决定),因此“先读后赋”的同名变量会
UnboundLocalError。
代码或图示
x = "global"
def outer():
x = "enclosing"
def inner():
print(x) # enclosing
inner()
def bad():
print(counter) # UnboundLocalError:下面有赋值,counter 被视为 Local
counter = 1
常见误区
- 类体不是闭包作用域:类体内的名字对方法不可见,方法必须通过
self或类名访问。 - 推导式在 Python 3 有独立作用域,循环变量不外泄;混淆 Py2/Py3 语义会误判变量泄漏。
追问
- 为什么会出现
UnboundLocalError?答:编译期已把该名字标记为局部变量,读取发生在赋值前。 - 类体为什么不算 Enclosing?答:类作用域不是闭包,方法定义时不会捕获类体名字,这是刻意设计。
- 如何显式访问模块全局?答:
global x声明或在函数内import sys; sys.modules[__name__].x(不推荐)。
04.7.2-005 global 和 nonlocal 有什么区别?
一句话结论
global 让赋值作用于模块级名字;nonlocal 让赋值作用于最近一层外层函数作用域的已有名字(不含全局)。nonlocal 要求外层确实存在该名字,否则 SyntaxError。
概念解释
- 不加声明时,函数内赋值只会创建/覆盖局部名字,外层变量不变。
nonlocal用于闭包计数器、状态机等需要修改外层变量的场景。
原理流程
global x声明后,对 x 的赋值绑定到模块全局命名空间。nonlocal n声明后,对 n 的赋值沿外层函数链向上定位已有名字,不进入全局作用域。- 声明只影响赋值绑定,不影响读取(读取本来就按 LEGB)。
代码或图示
count = 0
def inc_global():
global count
count += 1
def make_counter():
n = 0
def inc():
nonlocal n
n += 1
return n
return inc
常见误区
nonlocal不能跨模块,也不能指向全局;全局用global。- 滥用全局状态会让测试困难、并发不安全,优先用参数/返回值或类封装。
追问
- 为什么闭包修改外层变量必须
nonlocal?答:否则n += 1被视为局部赋值,读取时 UnboundLocalError。 nonlocal能找到模块级变量吗?答:不能,模块级属于 global 作用域。- 有没有不用 nonlocal 的替代?答:用可变容器
box = {"n": 0}或类属性,修改容器内容不需要声明。
04.7.2-006 闭包的原理是什么?__closure__ 里存了什么?
一句话结论
内层函数引用了外层函数的局部变量时,被引用的变量被放进“cell 对象”,内层函数的 __closure__ 持有这些 cell 的元组;即使外层函数返回,cell 仍被引用,变量因此存活。这就是闭包。
概念解释
- cell 是“共享的可变槽位”,内外层看到的是同一份数据。
- 闭包捕获的是“变量”而不是“值”:外层后续修改会反映到内层。
原理流程
- 外层函数执行时,被内层引用的局部变量被包装进 cell 对象。
- 内层函数对象通过
__closure__持有这些 cell;func.__code__.co_freevars列出闭包变量名。 - 外层栈帧销毁后,cell 随闭包函数存活,
cell.cell_contents取值。
代码或图示
def outer():
msg = "hi"
def inner():
return msg
return inner
f = outer()
print(f.__closure__[0].cell_contents) # hi
print(f.__code__.co_freevars) # ('msg',)
常见误区
- 闭包会延长对象生命周期,可能造成内存滞留(大对象被小函数捕获)。
- 循环创建的闭包共享同一个 cell 会导致“延迟绑定”问题(见 04.7.2-007)。
追问
- 闭包和被捕获变量的生命周期关系?答:只要闭包函数存活,cell 里的对象就不会被回收。
- 为什么调试时看不到外层局部变量?答:外层栈帧已销毁,值只保留在 cell 中。
- 闭包和类怎么选?答:单一行为用闭包更轻;需要多个方法、状态可见性时用类。
04.7.2-007 循环里创建闭包为什么会“全都一样”?
一句话结论
Python 的闭包按“变量”捕获,循环中的 i 是同一个变量(同一个 cell),循环结束后所有闭包看到的是最终值。要让每个闭包固定当时的值,用默认参数 lambda i=i: ...、functools.partial 或工厂函数。
概念解释
- 函数定义时不会求值函数体,只创建函数对象;
i的读取发生在调用时。 - 同理适用于字典/列表里的回调、事件处理器。
原理流程
- 循环每轮创建的 lambda 共享外层同一个 cell 中的循环变量。
- 循环结束后 cell 里只剩最终值,所有闭包调用时都读到该值。
- 默认参数在定义时求值,
lambda i=i: i把当时的值冻结进__defaults__;工厂函数def make(i): return lambda: i每次调用创建新的 cell。
代码或图示
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs]) # [0, 1, 2]
bad = [lambda: i for i in range(3)]
print([f() for f in bad]) # [2, 2, 2]
常见误区
- 以为定义闭包时就把当前值复制进去:实际捕获的是变量本身。
- 在 GUI/异步回调里踩同一坑:所有按钮点击都触发同一个最后索引,表现为“点谁都一样”。
追问
- 为什么默认参数能解决?答:每个 lambda 的
__defaults__保存了各自的值,不再共享 cell。 functools.partial方案怎么写?答:partial(lambda i: i, i)把参数绑定到调用时固定。- 这个坑在 GUI/异步回调里怎么表现?答:所有按钮点击都触发同一个最后索引,表现为“点谁都一样”。
04.7.2-008 装饰器的本质是什么?语法糖展开后长什么样?
一句话结论
装饰器是“接收函数(或类)并返回新可调用对象”的高阶函数。@deco 等价于 func = deco(func),在函数定义时立即执行,因此装饰器在导入阶段就会运行。
概念解释
- 装饰器可叠加:
@a @b def f()等价于f = a(b(f)),靠近函数的先包装。 - 装饰器返回值不一定是函数,也可以是任意可调用对象(类实例、
functools.partial)。
原理流程
- 模块加载执行到
@deco行时,把刚定义好的原函数传给 deco。 - deco 用 wrapper 包装后返回新可调用对象,重新绑定到函数名。
- 之后每次调用该名字,实际进入 wrapper。
代码或图示
def deco(func):
def wrapper(*a, **kw):
print("before")
return func(*a, **kw)
return wrapper
@deco
def hello():
print("hi")
# 等价于 hello = deco(hello)
常见误区
- 装饰发生在定义时,所以装饰器里不能依赖“调用时才存在的状态”,除非写成惰性。
- 装饰器本身可以有副作用(注册路由、注册任务),Flask/FastAPI/Celery 都靠这个;无参与带参装饰器是两种形态,后者本质是“返回装饰器的工厂”。
追问
- 为什么装饰器在导入时就执行?答:
@是定义语句的一部分,模块加载时立即求值并重新绑定名字。 - 装饰器能改变函数签名吗?答:能,但会导致
inspect.signature与文档失真,需要functools.wraps或显式设置__signature__。 - 装饰器能装饰类吗?答:能,接收类并返回类或包装对象,常用于注册、单例、冻结。
04.7.2-009 functools.wraps 有什么用?不加会怎样?
一句话结论
wraps 把被装饰函数的 __name__、__doc__、__module__、__qualname__、__dict__、__wrapped__ 复制到包装函数上,保留元信息与 introspection。不加会导致日志名字错、文档丢失、inspect.signature 看到 (*args, **kwargs)、框架按函数名注册失效。
概念解释
wraps同时设置__wrapped__,inspect.unwrap可还原原函数,inspect.signature会顺着它取真实签名。- 只复制元信息,不改变调用行为。
原理流程
- 包装函数定义时,
@functools.wraps(func)把原函数元信息拷贝到 wrapper。 - 设置
__wrapped__指向原函数,供内省工具穿透包装层。 - 多层装饰叠加时每层都该加
wraps,否则元信息逐层丢失。
代码或图示
import functools
def deco(func):
@functools.wraps(func)
def wrapper(*a, **kw):
return func(*a, **kw)
return wrapper
常见误区
- 多层装饰只在最外层加 wraps,内层 wrapper 的元信息已经失真。
- Flask 路由、pytest fixture、Celery task 都依赖函数名/签名,缺失会出诡异错误;需要精确保留签名时可用
decorator库,它在定义期重写签名。
追问
wraps会复制__annotations__吗?答:会(3.2+ 起包含),因此类型提示也能保留。- 不复制签名会有什么实际故障?答:FastAPI 依赖签名做参数校验,缺签名会导致依赖注入失败或文档错误。
__wrapped__有什么用?答:让工具链“看穿”包装层,取到原始函数做签名分析与调试。
04.7.2-010 带参数的装饰器怎么写?为什么需要三层?
一句话结论
带参装饰器是“装饰器工厂”:最外层接收参数并返回真正的装饰器,第二层接收函数,第三层是包装函数。写成 @deco(arg) 时,先执行 deco(arg) 得到装饰器,再用它装饰函数。
概念解释
- 参数在“装饰时”求值一次,可复用于所有调用。
- 每层都应使用
functools.wraps。
原理流程
- 最外层
deco(arg)接收配置参数,返回内部装饰器_deco。 _deco(func)接收被装饰函数,返回 wrapper。- wrapper 闭包持有配置参数,每次调用时按配置执行原函数。
代码或图示
def retry(times=3):
def _deco(func):
@functools.wraps(func)
def wrapper(*a, **kw):
for i in range(times):
try:
return func(*a, **kw)
except Exception:
if i == times - 1:
raise
return wrapper
return _deco
@retry(times=2)
def fetch():
...
常见误区
- 若要参数可选(
@deco与@deco(...)都能用),需判断第一个参数是不是可调用对象,不能直接按两层写。 - 参数应校验并早失败,避免运行期才发现配置错误;装饰器参数若是可变对象,所有被装饰函数会共享同一份配置。
追问
- 为什么不能写成两层?答:两层时
deco(arg)会把参数当函数用,无法区分“装饰器参数”和“被装饰对象”。 - 如何支持可选参数?答:在工厂里判断
arg是否 callable,若是则直接当函数处理。 - 装饰器参数是可变对象会有什么问题?答:所有被装饰函数共享同一份配置,运行时修改会互相影响。
04.7.2-011 多个装饰器叠加时的执行顺序是什么?
一句话结论
包装顺序由内向外(靠近函数的先装饰),调用顺序由外向内(最外层先执行前置逻辑),返回时反向。@a @b def f 等价于 f = a(b(f)),调用 f() 先进入 a 的 wrapper,再进入 b 的 wrapper,最后进原函数。
概念解释
- 前置代码按 a → b → 原函数;后置代码按原函数 → b → a。
- 用
inspect.unwrap可剥离所有包装层拿到原函数。
原理流程
- 定义时先应用靠近函数的 b,再应用外层的 a,形成
a(b(f))的包装链。 - 调用时从最外层 a 开始执行前置逻辑,逐层向内到原函数。
- 返回时沿包装链反向执行各层后置逻辑。
代码或图示
def a(f):
def w():
print("a-before")
f()
print("a-after")
return w
def b(f):
def w():
print("b-before")
f()
print("b-after")
return w
@a
@b
def f(): print("f")
# 输出:a-before / b-before / f / b-after / a-after
常见误区
- 装饰器有副作用时(注册、验证),叠加顺序会改变注册结果;需要“先校验再缓存”与“先缓存再校验”效果不同,顺序是业务语义的一部分。
- 装饰器太多会让栈变深,异常 traceback 变长,调试成本上升。
追问
- 为什么
@a @b是a(b(f))?答:装饰器自上而下书写,但应用时从最靠近函数的那层开始逐层向外包装。 - 顺序会影响性能吗?答:会,例如把缓存放外层可避免重复鉴权,放内层则每次都鉴权。
- 如何确认实际顺序?答:打印
__wrapped__链或用inspect.unwrap逆推。
04.7.2-012 类装饰器和装饰类有什么区别?
一句话结论
“类作为装饰器”指用实现了 __call__ 的类实例去装饰函数,可保存状态、便于配置;“装饰类”指 @deco 作用在 class 上,接收类并返回类(或包装后的类)。两者都能替换被装饰对象,但类装饰器天然带状态。
概念解释
- 用类做函数装饰器:
__init__收函数,__call__转发调用,好处是状态放在实例属性上、语义清晰。 - 类装饰器实现单例:接收类,缓存实例后返回工厂函数或修改
__new__。
原理流程
- 类装饰器在
__init__保存被装饰函数或类引用。 - 每次调用经过
__call__,在转发前后执行计数、限流、状态记录等逻辑。 - 状态字段挂在实例属性上,无需 nonlocal 或闭包 cell。
代码或图示
class CountCalls:
def __init__(self, func):
self.func = func
self.count = 0
def __call__(self, *a, **kw):
self.count += 1
return self.func(*a, **kw)
@CountCalls
def work(): ...
常见误区
- 装饰类时若返回非类对象,
isinstance、继承、类型注解都会失真。 - 装饰器链对类同样适用,但要注意元类冲突;类装饰器可用
__set_name__、__init_subclass__自动注册子类。
追问
- 类装饰器能保留函数签名吗?答:需要手动设置
__wrapped__/__signature__,否则 introspection 失效。 - 为什么类装饰器更适合做限流/计数?答:状态天然存在实例上,不必用 nonlocal 或闭包 cell。
- 装饰类时如何保持可继承?答:返回原类(只做注册/校验),或返回
type创建的子类,别返回函数。
04.7.2-013 用装饰器包装实例方法时要注意什么?
一句话结论
方法装饰器包装的是“未绑定的函数”,调用时 self 会作为第一个位置参数传入 wrapper;因此 wrapper 必须用 *args 接收,且 __get__ 描述符协议要能正确绑定。若返回类实例(类装饰器)而非函数,方法会失去自动绑定。
概念解释
def wrapper(self, *a, **kw)或def wrapper(*a, **kw)都可,后者更通用。property也是描述符,叠加时要放在最内层。
原理流程
- 类属性查找方法时,描述符协议通过
__get__把实例绑定为第一个参数。 - 函数装饰器返回的仍是函数,保留
__get__,因此方法自动绑定 self。 - 类实例装饰器没有
__get__,需要自己实现__get__返回functools.partial(self.__call__, obj)完成绑定。
代码或图示
class Deco:
def __init__(self, func): self.func = func
def __get__(self, obj, objtype=None):
return functools.partial(self.__call__, obj)
def __call__(self, obj, *a, **kw):
return self.func(obj, *a, **kw)
常见误区
- 用类实例装饰方法却不实现
__get__,导致obj.method不会自动传 self。 staticmethod/classmethod与自定义装饰器叠加顺序会影响是否绑定;继承体系中装饰器会随方法一起继承,注意状态是否共享。
追问
- 为什么类实例装饰方法会丢 self?答:实例不是函数,没有
__get__,属性访问不做绑定。 *args写法会不会吞掉关键字参数?答:不会,**kwargs负责关键字;但要确保签名允许。- 装饰器和
@property的顺序怎么定?答:@property放最外层(最靠近@的行在上),否则属性访问会失效。
04.7.2-014 lru_cache 的原理是什么?适合什么场景?
一句话结论
functools.lru_cache 用 dict 缓存“参数 → 返回值”,带容量上限,超出按最近最少使用淘汰。适合纯函数、参数可哈希、重复调用多的场景(递归、配置解析、昂贵计算)。不适合有副作用、参数不可哈希、结果随外部状态变化的函数。
概念解释
- 缓存键由位置参数与关键字参数的规范化形式组成;
f(a=1)与f(1)可能被视为不同键。 - 缓存是进程内的,多进程/多实例不共享;也不做持久化。
原理流程
- 调用时按参数规范化形式生成缓存键,在内部 dict 查找。
- 命中则直接返回缓存值;未命中则执行原函数并写入缓存。
- 容量达到
maxsize时按 LRU 淘汰最久未使用条目;cache_info()看命中统计,cache_clear()清理。
代码或图示
from functools import lru_cache
@lru_cache(maxsize=128)
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(30), fib.cache_info())
常见误区
maxsize=None表示无界缓存,长尾参数下容易内存泄漏。typed=True让1与1.0视为不同键;默认不区分类型,混用时需留意。
追问
- 为什么递归函数加缓存后快这么多?答:把指数级重复子问题压成线性,每个 n 只算一次。
- 缓存会返回同一个可变对象吗?答:会,返回的是引用;调用方修改会污染后续结果,必要时返回拷贝。
- 多进程下缓存有效吗?答:无效,每个进程独立内存;需要跨进程共享得用 Redis 等外部缓存。
04.7.2-015 使用 lru_cache 有哪些常见坑?
一句话结论
主要四类:参数不可哈希直接 TypeError;无界缓存导致内存泄漏;缓存返回可变对象被外部修改;把“依赖外部状态”的函数缓存后结果过期。另外实例方法缓存会把 self 作为 key,导致实例无法释放。
概念解释
- list/dict 参数不可哈希,需先转 tuple/frozenset 或改签名。
- 并发下缓存本身线程安全(内部锁),但被缓存函数若有副作用仍会出错。
原理流程
- 不可哈希参数在生成缓存键时直接抛 TypeError。
- 长尾参数(用户 ID、URL)配合
maxsize=None使缓存条目无限增长。 - 实例方法的
self进入缓存键,缓存条目持有实例强引用,阻止 GC 回收。 - 结果依赖时间、随机数、数据库时,缓存产生脏读,需要显式失效或 TTL。
代码或图示
@lru_cache(maxsize=1024)
def load(path): # path 是 str,可哈希
return open(path, encoding="utf-8").read()
def query(ids): # list 不可哈希
return _query(tuple(ids))
常见误区
- 实例方法上使用 lru_cache 导致内存泄漏:缓存键包含 self,实例回收不了;用
WeakValueDictionary或按实例分别缓存。 - 把依赖外部状态的结果长期缓存:需要显式失效或 TTL;标准库没有 TTL,可用
cachetools.TTLCache或自己封装时间戳。
追问
- 为什么实例方法缓存会导致内存泄漏?答:缓存键包含 self,缓存条目持有实例强引用,实例永远无法回收。
- 如何给缓存加 TTL?答:标准库没有,用
cachetools.TTLCache或自己封装时间戳。 - 缓存键冲突会怎样?答:不同类型参数哈希相同但值不同,
typed=True可区分类型,仍建议用明确签名。
04.7.2-016 functools.partial 有什么用?和 lambda 有什么区别?
一句话结论
partial(func, *args, **kwargs) 冻结部分参数,返回新的可调用对象;相比 lambda,它不创建新的 Python 帧、保留原函数元信息、可被 pickle(顶层函数),更适合回调与配置化调用。
概念解释
- 典型用途:
partial(int, base=2)、partial(json.dumps, ensure_ascii=False)、GUI 回调绑定参数。 - 关键字参数可被后续调用覆盖(新关键字优先)。
原理流程
- partial 内部记录原函数与已冻结的位置/关键字参数。
- 调用时把冻结位置参数排在最前,再追加新传入参数。
- 通过
__signature__反映已绑定参数,inspect 能显示剩余参数。
代码或图示
from functools import partial
b2 = partial(int, base=2)
print(b2("1010")) # 10
dump = partial(json.dumps, ensure_ascii=False)
常见误区
partial可在调用时继续追加位置参数,冻结的位置参数排在最前,追加顺序容易混淆。- 不支持像 lambda 那样写表达式逻辑,只能绑定参数;
partial(obj.method, x)会强引用 obj,注意对象生命周期。
追问
partial能绑定 self 吗?答:能,partial(obj.method, x)常用于回调;注意它会强引用 obj。- 为什么回调里更推荐 partial?答:避免闭包延迟绑定,也便于测试与序列化。
partial会改变函数签名吗?答:它通过__signature__反映已绑定参数,inspect能正确显示剩余参数。
04.7.2-017 functools.singledispatch 解决什么问题?
一句话结论
它实现“按第一个参数的类型分派”的泛型函数:用 @func.register(Type) 注册不同类型实现,调用时按参数类型选择,避免一长串 isinstance 分支。适合“同一操作、不同类型不同实现”的场景。
概念解释
- 分派基于第一个参数的实际类型,按 MRO 找最匹配的注册类型。
- 与
isinstance链相比,注册表是显式的、可扩展的,第三方可注册自己的类型。
原理流程
- 基函数用
@singledispatch定义默认实现。 - 各类型实现用
@to_json.register(dict)注册到分派表。 - 调用时按第一个参数类型在 MRO 上找最匹配实现,未注册类型走基函数。
代码或图示
from functools import singledispatch
@singledispatch
def to_json(obj):
return str(obj)
@to_json.register(dict)
def _(obj):
return {k: to_json(v) for k, v in obj.items()}
@to_json.register(list)
def _(obj):
return [to_json(v) for v in obj]
常见误区
- 不适合按值分派(值分派用字典映射),也不能按多个参数分派(标准库不能,需要
multimethod类库)。 - 注册类型与 MRO 匹配不当会命中意外的默认实现,需用具体类型注册并测试子类。
追问
- 分派顺序是怎样的?答:精确类型优先,然后按 MRO 向上找,最后回落到基函数。
- 能按多个参数分派吗?答:标准库不能,需要
multimethod类库。 - 这和“策略模式”什么关系?答:本质是把策略注册表嵌进函数,省去显式工厂。
04.7.2-018 map/filter/reduce 和推导式怎么选?
一句话结论
简单映射与过滤优先用推导式:可读、无函数调用开销、返回具体容器;map/filter 适合已有现成函数、需要惰性迭代或与 itertools 串成管道;reduce 适合自定义累积逻辑,但通常 sum/min/max/any/all 更清晰。
概念解释
map(f, xs)返回迭代器,list(map(...))才得到列表;推导式直接给列表。- 已有具名函数时
map(str.strip, lines)比[x.strip() for x in lines]更简洁且更快。
原理流程
- 推导式在 CPython 内建指令下直接构造容器。
- map/filter 返回惰性迭代器,逐个产出元素,可串联 itertools 管道。
- reduce 从左到右把累积值与下一元素交给归约函数,需要初值避免空序列报错。
代码或图示
from functools import reduce
print(list(map(int, ["1", "2"])))
print(sum(x for x in range(10) if x % 2))
print(reduce(lambda a, b: a * b, [1, 2, 3, 4], 1))
常见误区
filter(None, xs)会过滤所有假值,语义隐晦,容易误删 0。reduce需要导入,且初值缺失时对空序列报 TypeError;多个转换串联应使用生成器表达式管道,避免中间列表。
追问
- 为什么
map在 Python 3 返回迭代器?答:与zip/range一致,省内存、支持无限流。 - 什么时候
reduce比循环好?答:累积逻辑是纯函数且已有对应运算符时;否则显式循环更易读。 - 推导式和生成器表达式怎么选?答:需要多次遍历/长度用列表;一次性流式处理用生成器。
04.7.2-019 lambda 有哪些限制?什么时候不该用?
一句话结论
lambda 只能是单表达式,不能含语句(赋值、循环、try、return 等),没有名字(__name__ 为 <lambda>),traceback 与日志可读性差,不能写文档字符串。简单一次性回调可用,复杂逻辑必须用 def。
概念解释
- lambda 内可用三元表达式、
and/or、函数调用,但不能用多语句结构(海象可以但很绕)。 - lambda 捕获变量按引用,不复制值(除默认参数)。
原理流程
- lambda 定义时编译为单表达式函数体,函数体只能产生一个返回值。
- 函数对象没有限定名,
__name__固定为<lambda>,profiling 与日志难以定位。 - 匿名函数不可被 pickle 按模块限定名定位,序列化与多进程场景必须用顶层 def。
代码或图示
sorted(items, key=lambda x: (x.age, x.name)) # 合适
# 不适合:多分支、异常处理、日志打点
常见误区
- 默认参数技巧
lambda x=x: ...可修复延迟绑定,但容易被忽略。 - 需要序列化(pickle/多进程)时 lambda 不可用,必须顶层 def;大数据下每元素一次 Python 调用,可用
operator.itemgetter/attrgetter替代。
追问
- 为什么 lambda 不能 pickle?答:pickle 按“模块 + 限定名”定位对象,lambda 没有稳定名字。
- lambda 里有赋值怎么办?答:不能直接写,只能拆成 def 或用海象运算符(不推荐)。
key=lambda有性能问题吗?答:每元素一次 Python 调用,大数据可用operator.itemgetter/attrgetter替代。
04.7.2-020 Python 的递归有什么限制?为什么没有尾递归优化?
一句话结论
默认递归深度约 1000 层(sys.getrecursionlimit()),超过抛 RecursionError;CPython 不做尾调用优化,因为要保留完整栈帧以支持 traceback、调试与 sys.settrace,且语言设计上不承诺。
概念解释
- 每层递归都创建新帧,占用 C 栈与 Python 帧对象,深递归可能直接崩溃。
- 递归适合树/图遍历、分治等天然递归结构,深度可控时使用。
原理流程
- 每次函数调用在调用栈上压入 Python 帧对象与对应 C 栈帧。
- 帧达到
recursionlimit阈值时抛 RecursionError。 - CPython 保留完整栈帧供回溯、断点与追踪使用,因此不丢弃尾调用帧。
代码或图示
import sys
print(sys.getrecursionlimit()) # 1000
def fact(n):
return 1 if n <= 1 else n * fact(n - 1)
常见误区
- 可
sys.setrecursionlimit()调高,但过高有 C 栈溢出风险,不是解决方案。 - 记忆化(lru_cache)能减少重复子问题,但不减少递归深度;深层递归应改显式栈或迭代。
追问
- 为什么提高递归上限危险?答:每层还消耗 C 栈,超限会段错误而非优雅异常。
- 怎么判断该改迭代?答:深度随输入线性增长(链表、深树、长路径)时必须改。
- 有第三方尾递归优化吗?答:可用装饰器模拟(每次返回 thunk 由 trampoline 驱动),但破坏常规调用语义。
04.7.2-021 如何把递归改成迭代?
一句话结论
两种通用手法:用显式栈模拟调用栈(适合树/图遍历、回溯),或把递归关系转成循环 + 累积变量(适合线性递推、动态规划)。核心是把“待处理状态”显式保存,而不是依赖函数帧。
概念解释
- 线性递归(阶乘、斐波那契)改成循环 + 两个累积变量。
- 回溯(全排列、组合)用“路径列表 + 选择列表”手动回溯。
原理流程
- DFS 用
stack = [root],弹出后把子节点压栈;需要后序处理时压入标记或两次入栈。 - 线性递推用循环更新累积变量,从边界状态向前推导。
- 用栈时要考虑顺序:栈是 LIFO,压入顺序与递归顺序相反。
代码或图示
def walk(root):
stack, out = [root], []
while stack:
node = stack.pop()
out.append(node.val)
stack.extend(reversed(node.children))
return out
常见误区
- 迭代版更省内存、可控深度,但代码可读性通常下降;后序遍历需额外标记或双栈法。
- 显式栈在堆上分配,不受 C 栈深度限制,但空间复杂度同为 O(深度)。
追问
- 显式栈和递归栈的复杂度一样吗?答:时间同阶,空间同为 O(深度),但显式栈在堆上,不受 C 栈限制。
- 后序遍历怎么用栈实现?答:压入“节点 + 状态标记”,或用双栈法(前序反转)。
- 什么时候保留递归?答:深度可控、结构天然递归、可读性收益明显时。
04.7.2-022 “函数是一等对象”意味着什么?
一句话结论
函数可以赋值给变量、作为参数/返回值、放进容器、加属性、被装饰、被内省(__name__、__doc__、__code__)。这使 Python 天然支持高阶函数、回调、策略模式与装饰器。
概念解释
- 函数对象有
__dict__,可挂元数据(很多框架用它注册路由)。 - 函数本身可调用,
callable(f)判断;类、方法、实现了__call__的实例也都可调用。
原理流程
- 函数定义在执行期生成函数对象,名字绑定到该对象。
- 函数对象可被传递、返回、存入字典列表,或在运行时创建(闭包、工厂)。
- 函数可动态替换(monkey patch),其属性全局共享。
代码或图示
def hello(): return "hi"
hello.tag = "demo"
handlers = {"greet": hello}
print(handlers["greet"]())
常见误区
- 函数属性是全局的,给同一函数挂状态在多处使用时可能互相干扰。
- 一等对象是装饰器、
map/filter、回调式 API 的基础;不要把函数名与函数对象混为一谈。
追问
- 类的实例为什么也可调用?答:实现了
__call__,obj()等价于type(obj).__call__(obj)。 - 函数加属性有什么风险?答:属性属于函数对象本身,全局共享,容易成为隐式单例状态。
- 一等对象和闭包什么关系?答:闭包是“运行时创建的函数”,正因为它是一等对象才能被返回和传递。
04.7.2-023 __call__ 有什么用?和普通函数有什么区别?
一句话结论
__call__ 让实例像函数一样被调用,obj(*args) 等价于 type(obj).__call__(obj, *args)。区别在于实例可携带状态、可被多个方法共享、可继承;函数没有实例状态,只有属性。
概念解释
- 适合“带配置的处理器”:
Retry(times=3)(func)、Normalizer(strip=True)(text)。 - 类装饰器、策略对象、状态机、缓存包装常用
__call__。
原理流程
- 构造时通过
__init__把配置存入实例属性。 - 调用实例时触发
__call__,在实例状态上执行处理逻辑。 callable(obj)对实现了__call__的实例返回 True。
代码或图示
class Adder:
def __init__(self, n): self.n = n
def __call__(self, x): return x + self.n
add3 = Adder(3)
print(add3(4)) # 7
常见误区
- 与
__init__不同:__init__只在构造时调用,__call__每次调用都执行。 - 用作方法装饰器时需要处理
__get__绑定(见 04.7.2-013);实例可调用会被当作 callable,但isinstance(obj, types.FunctionType)仍为 False。
追问
__call__和闭包怎么选?答:需要多个状态字段、多个方法、可继承时用类;单一行为用闭包。- 实例可调用会影响类型判断吗?答:会被当作 callable,但
isinstance(obj, types.FunctionType)仍为 False。 - 能实现异步调用吗?答:定义
async def __call__即可返回协程对象。
04.7.2-024 函数注解和 inspect.signature 有什么用?
一句话结论
注解(def f(x: int) -> str)存进 __annotations__,运行时不强制校验,供类型检查器、框架、文档使用;inspect.signature 把参数名、默认值、注解、参数种类结构化,是依赖注入、参数校验、装饰器保持签名的核心工具。
概念解释
- 注解可以是任意对象(字符串、类型、
Annotated元数据),from __future__ import annotations会让它们变成字符串延迟求值。 - FastAPI/Pydantic 用签名 + 注解做请求校验与文档生成。
原理流程
- 定义时注解表达式求值(或被延迟为字符串),存入
__annotations__。 inspect.signature解析函数的参数列表、默认值、注解与参数种类。Signature.bind可模拟调用绑定,用于参数预校验;签名解析会遵循__wrapped__。
代码或图示
import inspect
def f(a: int, b: str = "x") -> bool:
return True
print(f.__annotations__) # {'a': int, 'b': str, 'return': bool}
print(inspect.signature(f)) # (a: int, b: str = 'x') -> bool
常见误区
- 注解不是契约,mypy 只在静态阶段检查;运行时校验需 Pydantic 等库。
- 运行时改了注解不报错,因为注解只是普通属性,Python 不做强制类型检查。
追问
- 为什么运行时改了注解不报错?答:注解只是普通属性,Python 不做强制类型检查。
__wrapped__与签名有什么关系?答:inspect.signature默认跟随__wrapped__,所以wraps装饰后签名看起来没变。- 注解能存额外元数据吗?答:用
typing.Annotated[int, "gt=0"],FastAPI 就是这样传约束的。
04.7.2-025 默认参数的求值时机是什么?如何实现“每次调用都重新求值”?
一句话结论
默认参数在 def 执行时求值一次,存进 __defaults__/__kwdefaults__,之后所有调用复用同一对象。若想每次调用重新求值(如 now()、空容器),用 None 哨兵在函数体内创建,或用工厂函数/functools.partial 延迟绑定。
概念解释
- 这是一条“定义期 vs 调用期”的通用规律:装饰器、注解、默认值都在定义期求值。
- 空容器默认值会被跨调用共享,导致数据串味。
原理流程
- 执行
def语句时,默认参数表达式求值一次,结果对象挂到__defaults__或__kwdefaults__。 - 调用未显式传参时,复用该默认对象。
- 需要每次新建时,默认值传
None,函数体内判断后再创建。
代码或图示
def now_str(ts=None):
ts = time.time() if ts is None else ts
return time.strftime("%H:%M:%S", time.localtime(ts))
常见误区
def f(x=time.time())会固定在定义那一刻;需要可变默认值又不想共享:if x is None: x = []。- 想缓存计算结果:那是特性不是 bug,但应显式命名为缓存并说明;装饰器参数同样在装饰时求值,之后被所有调用共享。
追问
- 为什么
def f(x=[])的列表会一直增长?答:默认列表对象被函数对象持有,每次调用都在同一个列表上 append。 - 如何查看当前默认值?答:
f.__defaults__、f.__kwdefaults__,调试时很有用。 - 装饰器参数也会这样吗?答:会,
@retry(times=3)的参数在装饰时求值,之后被所有调用共享。
04.7.2-026 关键字参数解包 ** 有哪些规则和冲突点?
一句话结论
f(**mapping) 把字典展开为关键字参数,键必须是字符串且是合法标识符;与显式关键字冲突会 TypeError(重复赋值);多个 ** 合并时后者覆盖前者(3.5+)。
概念解释
**只能用于映射类型,list/tuple 会 TypeError。- 与
*args同时使用时,位置参数在前、关键字在后,顺序错误会 TypeError。
原理流程
- 解包时字典键作为关键字参数名,按字典顺序与形参匹配。
- 同一参数被显式关键字与
**同时赋值,报重复赋值 TypeError。 - 多个
**合并时同名键以后者为准(字典合并语义)。
代码或图示
def f(a, b): ...
f(**{"a": 1, "b": 2}) # OK
f(**{"a": 1}, **{"a": 2}) # TypeError: multiple values for 'a'
常见误区
- 键含连字符等非法标识符会失败;键不是 str 直接 TypeError。
- 显式关键字与
**同名冲突时不会自动覆盖,直接报错;转发未知参数应在边界处显式白名单过滤。
追问
- 为什么键必须是字符串?答:关键字参数名在调用协议中是标识符,非字符串无法映射到形参。
- 字典合并
{**a, **b}与函数解包规则一致吗?答:一致,后者覆盖前者。 - 如何安全转发未知参数?答:用
*args, **kwargs透传,或在边界处显式白名单过滤。
04.7.2-027 用装饰器实现“重试”要注意什么?
一句话结论
重试要明确四件事:重试哪些异常、最多几次、间隔策略(固定/指数退避+抖动)、是否幂等。还要避免无界重试、避免重试不可恢复错误(参数校验、鉴权失败),并保留原始异常与调用栈。
概念解释
- 只捕获可重试异常(网络超时、连接重置、限流),不要吞
KeyboardInterrupt/SystemExit(继承 BaseException)。 - 重试前确认操作幂等(GET、带幂等键的写),否则会重复扣款/重复下单。
原理流程
- 循环最多执行 times 次,按指定异常类型捕获。
- 捕获后按退避策略等待(指数退避加随机抖动),再进入下一次尝试。
- 最后一次失败要
raise原异常,不要返回 None 掩盖错误;记录重试次数与原因便于观测。
代码或图示
def retry(times=3, base=0.5, exceptions=(TimeoutError,)):
def deco(func):
@functools.wraps(func)
def wrapper(*a, **kw):
for i in range(times):
try:
return func(*a, **kw)
except exceptions:
if i == times - 1:
raise
time.sleep(base * (2 ** i) + random.uniform(0, 0.1))
return wrapper
return deco
常见误区
- 无界重试放大延迟与负载;不可恢复错误(逻辑错误、鉴权失败)重试也不会成功。
- 重试总时长应小于上游超时;分布式下多副本同时重试会形成重试风暴,需要抖动 + 熔断 + 限流。
追问
- 为什么不能重试所有异常?答:逻辑错误重试也不会成功,只会放大延迟与负载。
- 重试和超时如何配合?答:外层设总超时,内层每次设单次超时,避免总耗时失控。
- 分布式下重试有什么额外风险?答:多副本同时重试会形成重试风暴,需要抖动 + 熔断 + 限流。
04.7.2-028 用装饰器做计时/日志要注意什么?
一句话结论
计时要用 time.perf_counter()(单调高精度),日志要用 logger 而不是 print,并保留 wraps 以显示真实函数名;同时注意装饰器本身的开销、异常路径也要记录耗时、异步函数要用 async 包装。
概念解释
- 异常路径应在
finally中记录耗时,否则失败调用没有指标。 - 日志参数化:
logger.info("%s cost %.1fms", name, cost),避免提前格式化。
原理流程
- 进入 wrapper 时用单调时钟记录起始时刻。
- 调用原函数,无论成功或异常都在
finally计算耗时并记录。 - 异步函数需
async def wrapper+await,同步 wrapper 会把协程对象直接返回而不 await。
代码或图示
def timed(func):
@functools.wraps(func)
def wrapper(*a, **kw):
t0 = time.perf_counter()
try:
return func(*a, **kw)
finally:
logger.info("%s cost %.1fms", func.__name__, (time.perf_counter() - t0) * 1000)
return wrapper
常见误区
time.time()会被 NTP 跳变影响,可能出现负耗时或跳变;高 QPS 下逐调用打日志会拖慢服务,应采样或只记录慢调用。- 装饰同步函数与异步函数要分开写;只记录成功路径会漏掉失败调用的耗时指标。
追问
- 为什么不用
time.time()?答:它可能被系统时钟调整,出现负耗时或跳变。 - 异步函数能用同一个装饰器吗?答:不能,同步 wrapper 会把协程对象直接返回而不 await。
- 生产上如何避免日志开销?答:只对超过阈值的调用记录,或用采样率控制。
04.7.2-029 柯里化和偏函数应用有什么区别?
一句话结论
柯里化把多参函数逐次转成单参函数链(f(a)(b)(c)),偏函数应用是固定部分参数后得到新函数(partial(f, a))。Python 没有自动柯里化,通常用 partial 或嵌套 lambda/装饰器模拟。
概念解释
- 柯里化强调“一次一个参数”的变换过程,便于组合与管道。
- 装饰器本质就是“参数化 + 返回函数”,是偏应用的语法形态。
原理流程
- 柯里化每接收一个参数就返回一个新的单参函数,直到凑齐全部参数。
- 偏函数应用一次性冻结部分参数,得到可继续调用的新可调用对象。
partial可一次固定多个参数,且能继续追加位置/关键字参数。
代码或图示
def add(a):
return lambda b: a + b
add5 = add(5)
print(add5(3)) # 8
from functools import partial
add5b = partial(lambda a, b: a + b, 5)
常见误区
- 需要自动柯里化的库可用
toolz.curry,但会牺牲签名清晰度。 - 团队代码中显式 lambda/partial 更易读,别为了“函数式”而过度柯里化。
追问
- 柯里化适合什么场景?答:组合高阶函数、构造配置化管道、复用部分参数。
- 为什么 Python 不默认柯里化?答:与默认参数、可变参数、关键字参数机制冲突,且不利于 introspection。
- 偏应用能替代柯里化吗?答:多数工程场景可以,且
partial保留签名信息更好。
04.7.2-030 如何写一个既能装饰函数、又能装饰类的装饰器?
一句话结论
先判断被装饰对象类型:inspect.isfunction/callable 与 inspect.isclass 分支处理;函数走 wrapper,类可只做注册/校验后原样返回,或返回包装后的类。关键是不要盲目对所有对象套同一种 wrapper,否则类会变成函数,破坏 isinstance 与继承。
概念解释
- 装饰类时若只需副作用(注册、校验),直接
return cls最安全。 - 装饰函数时用
wraps保留元信息。
原理流程
- 装饰器入口先判断被装饰对象是类还是函数。
- 类分支:执行注册/校验等副作用后原样返回,或返回子类包装。
- 函数分支:返回带
__wrapped__的 wrapper,保留原函数元信息。
代码或图示
def register(obj):
if inspect.isclass(obj):
REGISTRY[obj.__name__] = obj
return obj
@functools.wraps(obj)
def wrapper(*a, **kw):
return obj(*a, **kw)
wrapper.__wrapped__ = obj
return wrapper
常见误区
- 装饰类后随便返回函数:类会失去类型身份,
isinstance、继承、类型注解全部失效。 - 用
isinstance(obj, type)判断元类相关对象时可能误判;混合装饰器要写清文档:对不同对象返回什么,避免调用方误解。
追问
- 为什么装饰类后不能随便返回函数?答:类会失去类型身份,
isinstance、继承、类型注解全部失效。 - 如何在装饰类时修改方法?答:遍历
cls.__dict__包装方法,或用元类/__init_subclass__。 - 这种装饰器怎么测试?答:分别对函数与类写用例,断言返回对象的类型与行为都符合预期。
本节高频题
- 参数传递机制(001)
*args/**kwargs(002)- 闭包原理(006)
- 循环闭包延迟绑定(007)
- 装饰器原理与顺序(008、011)
functools.wraps(009)- 带参装饰器(010)
lru_cache原理与坑(014、015)partial(016)- 递归限制(020)
- 函数注解与签名(024)
- 默认参数求值时机(025)