17370845950

Python默认参数在定义时求值，可变对象作默认值会导致状态污染；闭包捕获变量引用而非值，循环中易出错；二者叠加更危险，应改用None+初始化、类封装或nonlocal等安全方式。

默认参数在函数定义时就完成求值

Python 中的默认参数不是在每次调用时重新计算，而是在函数定义

例如：

def bad_append(item, lst=[]):
    lst.append(item)
    return lst
print(bad_append(1))  # [1]
print(bad_append(2))  # [1, 2] ← 意外！复用了上一次的列表

解决方法：用 None 作为占位默认值，在函数体内初始化：

• 把 lst=[] 改成 lst=None
• 在函数开头加 if lst is None: lst = []

闭包中变量捕获的是引用而非快照

在循环中创建多个闭包（比如用 lambda 或嵌套函数），它们共享对外层循环变量的引用，而不是各自保存当时变量的值。当循环结束，所有闭包看到的都是循环变量的最终值。

典型问题代码：

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])  # [2, 2, 2] ← 不是期望的 [0, 1, 2]

根本原因是：每个 lambda 都引用了同一个变量 i，而循环结束后 i == 2。

修复方式有几种：

• 用默认参数“快照”当前值：lambda i=i: i
• 用闭包工厂函数封装：def make_f(x): return lambda: x，然后 funcs.append(make_f(i))
• 在 Python 3.8+ 中也可用海象运算符配合生成器表达式，但默认参数法最常用

默认参数 + 闭包组合时的双重陷阱

当一个函数既有默认参数又是闭包（比如嵌套函数返回内层函数），且默认参数本身是可变对象，又在闭包内部被修改，就容易出现难以察觉的状态污染。

示例：

def make_adder(base=0):
    def add(x, cache=[]):  # ❌ cache 是默认可变参数
        cache.append(x)
        return base + sum(cache)
    return add
f1 = make_adder(10)
f2 = make_adder(100)
print(f1(1))  # 11
print(f1(2))  # 14 ← cache 已累积 [1, 2]
print(f2(3))  # 103？错！其实是 106，因为 f2 复用了 f1 的 cache 列表

这里有两个问题叠加：

• cache=[] 在 add 定义时就绑定了一次，所有 add 实例共享该列表
• make_adder 被多次调用，但每次返回的 add 函数都指向同一个函数对象（因函数体相同、默认参数相同），实际共用同一份默认参数

正确写法应同时规避两个坑：

• 把 cache=[] 改为 cache=None，并在函数内初始化
• 确保每次调用 make_adder 返回的闭包是独立函数对象（上面例子中其实已经是，但默认参数污染仍存在）

如何安全地设计带状态的闭包

如果确实需要在闭包中维护状态，推荐显式方式，避免依赖默认参数：

• 用类封装状态：清晰、可读、可测试
• 用 functools.partial 绑定部分参数，比默认参数更可控
• 用 nonlocal 声明并修改外层变量（仅限简单计数或单值状态）
• 若坚持用默认参数，只对不可变对象（如 None、数字、字符串、元组）设默认值

记住：默认参数适合配置项，不适合状态容器；闭包适合捕获环境，不适合隐式共享可变数据。