罗罗编程学习记录
本页内容 展开查看

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 会直接改到原对象,表现得像引用传递。

原理流程

  1. 调用时把实参对象的引用复制一份绑定到形参,形参与实参指向同一个对象。
  2. 形参重新绑定到新对象,只改局部名字,不写回实参变量。
  3. 通过形参原地修改可变对象内容,调用方持有的引用能观察到变化。

代码或图示

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 只是习惯,真正语义由位置决定。

原理流程

  1. 定义时按位置参数、默认参数、*args、仅关键字参数、**kwargs 的顺序解析。
  2. 调用时 *seq 把序列展开为位置参数,**mapping 把字典展开为关键字参数。
  3. 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)),避免历史参数名绑死。

原理流程

  1. / 声明其左侧参数不参与按名传参,调用方只能按位置传入。
  2. * 声明其右侧参数必须按关键字传入,调用点强制写参数名。
  3. 用 / 后重命名参数不算破坏兼容;用 * 后新增参数更安全,不会与位置调用冲突。

代码或图示

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() 可查看。

原理流程

  1. 读取名字时先在当前函数局部命名空间查找。
  2. 未命中依次向外层函数、模块全局、内建命名空间查找。
  3. 赋值语句让名字成为 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 用于闭包计数器、状态机等需要修改外层变量的场景。

原理流程

  1. global x 声明后,对 x 的赋值绑定到模块全局命名空间。
  2. nonlocal n 声明后,对 n 的赋值沿外层函数链向上定位已有名字,不进入全局作用域。
  3. 声明只影响赋值绑定,不影响读取(读取本来就按 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 是“共享的可变槽位”,内外层看到的是同一份数据。
  • 闭包捕获的是“变量”而不是“值”:外层后续修改会反映到内层。

原理流程

  1. 外层函数执行时,被内层引用的局部变量被包装进 cell 对象。
  2. 内层函数对象通过 __closure__ 持有这些 cell;func.__code__.co_freevars 列出闭包变量名。
  3. 外层栈帧销毁后,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 的读取发生在调用时。
  • 同理适用于字典/列表里的回调、事件处理器。

原理流程

  1. 循环每轮创建的 lambda 共享外层同一个 cell 中的循环变量。
  2. 循环结束后 cell 里只剩最终值,所有闭包调用时都读到该值。
  3. 默认参数在定义时求值,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)。

原理流程

  1. 模块加载执行到 @deco 行时,把刚定义好的原函数传给 deco。
  2. deco 用 wrapper 包装后返回新可调用对象,重新绑定到函数名。
  3. 之后每次调用该名字,实际进入 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 会顺着它取真实签名。
  • 只复制元信息,不改变调用行为。

原理流程

  1. 包装函数定义时,@functools.wraps(func) 把原函数元信息拷贝到 wrapper。
  2. 设置 __wrapped__ 指向原函数,供内省工具穿透包装层。
  3. 多层装饰叠加时每层都该加 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。

原理流程

  1. 最外层 deco(arg) 接收配置参数,返回内部装饰器 _deco。
  2. _deco(func) 接收被装饰函数,返回 wrapper。
  3. 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 可剥离所有包装层拿到原函数。

原理流程

  1. 定义时先应用靠近函数的 b,再应用外层的 a,形成 a(b(f)) 的包装链。
  2. 调用时从最外层 a 开始执行前置逻辑,逐层向内到原函数。
  3. 返回时沿包装链反向执行各层后置逻辑。

代码或图示

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__。

原理流程

  1. 类装饰器在 __init__ 保存被装饰函数或类引用。
  2. 每次调用经过 __call__,在转发前后执行计数、限流、状态记录等逻辑。
  3. 状态字段挂在实例属性上,无需 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 也是描述符,叠加时要放在最内层。

原理流程

  1. 类属性查找方法时,描述符协议通过 __get__ 把实例绑定为第一个参数。
  2. 函数装饰器返回的仍是函数,保留 __get__,因此方法自动绑定 self。
  3. 类实例装饰器没有 __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) 可能被视为不同键。
  • 缓存是进程内的,多进程/多实例不共享;也不做持久化。

原理流程

  1. 调用时按参数规范化形式生成缓存键,在内部 dict 查找。
  2. 命中则直接返回缓存值;未命中则执行原函数并写入缓存。
  3. 容量达到 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 或改签名。
  • 并发下缓存本身线程安全(内部锁),但被缓存函数若有副作用仍会出错。

原理流程

  1. 不可哈希参数在生成缓存键时直接抛 TypeError。
  2. 长尾参数(用户 ID、URL)配合 maxsize=None 使缓存条目无限增长。
  3. 实例方法的 self 进入缓存键,缓存条目持有实例强引用,阻止 GC 回收。
  4. 结果依赖时间、随机数、数据库时,缓存产生脏读,需要显式失效或 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 回调绑定参数。
  • 关键字参数可被后续调用覆盖(新关键字优先)。

原理流程

  1. partial 内部记录原函数与已冻结的位置/关键字参数。
  2. 调用时把冻结位置参数排在最前,再追加新传入参数。
  3. 通过 __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 链相比,注册表是显式的、可扩展的,第三方可注册自己的类型。

原理流程

  1. 基函数用 @singledispatch 定义默认实现。
  2. 各类型实现用 @to_json.register(dict) 注册到分派表。
  3. 调用时按第一个参数类型在 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] 更简洁且更快。

原理流程

  1. 推导式在 CPython 内建指令下直接构造容器。
  2. map/filter 返回惰性迭代器,逐个产出元素,可串联 itertools 管道。
  3. 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 捕获变量按引用,不复制值(除默认参数)。

原理流程

  1. lambda 定义时编译为单表达式函数体,函数体只能产生一个返回值。
  2. 函数对象没有限定名,__name__ 固定为 <lambda>,profiling 与日志难以定位。
  3. 匿名函数不可被 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 帧对象,深递归可能直接崩溃。
  • 递归适合树/图遍历、分治等天然递归结构,深度可控时使用。

原理流程

  1. 每次函数调用在调用栈上压入 Python 帧对象与对应 C 栈帧。
  2. 帧达到 recursionlimit 阈值时抛 RecursionError。
  3. 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 如何把递归改成迭代?

一句话结论

两种通用手法:用显式栈模拟调用栈(适合树/图遍历、回溯),或把递归关系转成循环 + 累积变量(适合线性递推、动态规划)。核心是把“待处理状态”显式保存,而不是依赖函数帧。

概念解释

  • 线性递归(阶乘、斐波那契)改成循环 + 两个累积变量。
  • 回溯(全排列、组合)用“路径列表 + 选择列表”手动回溯。

原理流程

  1. DFS 用 stack = [root],弹出后把子节点压栈;需要后序处理时压入标记或两次入栈。
  2. 线性递推用循环更新累积变量,从边界状态向前推导。
  3. 用栈时要考虑顺序:栈是 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__ 的实例也都可调用。

原理流程

  1. 函数定义在执行期生成函数对象,名字绑定到该对象。
  2. 函数对象可被传递、返回、存入字典列表,或在运行时创建(闭包、工厂)。
  3. 函数可动态替换(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__。

原理流程

  1. 构造时通过 __init__ 把配置存入实例属性。
  2. 调用实例时触发 __call__,在实例状态上执行处理逻辑。
  3. 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 用签名 + 注解做请求校验与文档生成。

原理流程

  1. 定义时注解表达式求值(或被延迟为字符串),存入 __annotations__。
  2. inspect.signature 解析函数的参数列表、默认值、注解与参数种类。
  3. 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 调用期”的通用规律:装饰器、注解、默认值都在定义期求值。
  • 空容器默认值会被跨调用共享,导致数据串味。

原理流程

  1. 执行 def 语句时,默认参数表达式求值一次,结果对象挂到 __defaults__ 或 __kwdefaults__。
  2. 调用未显式传参时,复用该默认对象。
  3. 需要每次新建时,默认值传 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。

原理流程

  1. 解包时字典键作为关键字参数名,按字典顺序与形参匹配。
  2. 同一参数被显式关键字与 ** 同时赋值,报重复赋值 TypeError。
  3. 多个 ** 合并时同名键以后者为准(字典合并语义)。

代码或图示

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、带幂等键的写),否则会重复扣款/重复下单。

原理流程

  1. 循环最多执行 times 次,按指定异常类型捕获。
  2. 捕获后按退避策略等待(指数退避加随机抖动),再进入下一次尝试。
  3. 最后一次失败要 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),避免提前格式化。

原理流程

  1. 进入 wrapper 时用单调时钟记录起始时刻。
  2. 调用原函数,无论成功或异常都在 finally 计算耗时并记录。
  3. 异步函数需 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/装饰器模拟。

概念解释

  • 柯里化强调“一次一个参数”的变换过程,便于组合与管道。
  • 装饰器本质就是“参数化 + 返回函数”,是偏应用的语法形态。

原理流程

  1. 柯里化每接收一个参数就返回一个新的单参函数,直到凑齐全部参数。
  2. 偏函数应用一次性冻结部分参数,得到可继续调用的新可调用对象。
  3. 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 保留元信息。

原理流程

  1. 装饰器入口先判断被装饰对象是类还是函数。
  2. 类分支:执行注册/校验等副作用后原样返回,或返回子类包装。
  3. 函数分支:返回带 __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)