Python 两大经典坑点 —— 可变默认参数 & 闭包延迟绑定

1. 知识点简介

Python 的「灵活」有时也是双刃剑。下面这两个坑点隔三差五就出现在生产事故和面试题中，而且它们都来自同一个根源：Python 的绑定时机问题。

坑 ①：可变默认参数 ------ 默认参数在定义时求值，而非调用时
坑 ②：闭包延迟绑定 ------ 闭包捕获的是变量引用，而非创建时的值

理解这两个坑 = 理解 Python 作用域 + 绑定机制的关键。

2. 坑 ①：可变默认参数

现象

python 复制代码

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))          # [1]
print(add_item(2))          # [1, 2]  👈 预期是 [2]！
print(add_item(3))          # [1, 2, 3]

每次调用 add_item 时，items 指向的都是 同一个列表对象。

原因

Python 的默认参数值在函数定义时 （def 语句执行时）计算并绑定。之后每次调用若不传该参数，用的都是同一个对象。

验证一下：

python 复制代码

def test(items=[]):
    print(id(items))  # 每次调用都打印相同的内存地址

test()  # 4395790912
test()  # 4395790912
test()  # 4395790912

正确姿势

python 复制代码

# ✅ 用 None 做哨兵，函数内部创建新对象
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item(1))   # [1]
print(add_item(2))   # [2]  ✅ 符合预期

经典变种

python 复制代码

# 不只是 list，任何可变对象都一样
def bad(d={}):
    d["count"] = d.get("count", 0) + 1
    return d

print(bad())  # {'count': 1}
print(bad())  # {'count': 2}  ❌

python 复制代码

# 甚至连 Datetime 和 lambda 也不例外
import datetime

def log_time(t=datetime.datetime.now()):
    print(t)

log_time()  # 每次打印相同的时刻 ❌

3. 坑 ②：闭包延迟绑定

现象

python 复制代码

def create_multipliers():
    return [lambda x: i * x for i in range(5)]

multipliers = create_multipliers()
for m in multipliers:
    print(m(2))  # 输出：8 8 8 8 8  👈 预期：0 2 4 6 8

所有函数都返回 8？因为循环结束时 i = 4，所有闭包引用的都是同一个变量 i 的最终值。

原理拆解

python 复制代码

# 等价写法，更容易看穿
funcs = []
for i in range(5):
    funcs.append(lambda x: i * x)

i = 4  # 循环结束后的 i

for f in funcs:
    print(f(2))  # 全部 8

lambda 捕获的是变量 i 本身（引用），而非创建时 i 的值。当闭包真正执行 时，才去查找 i 的当前值。

正确姿势

方式 1：默认参数绑定（利用坑 ① 的特性反制）

python 复制代码

def create_multipliers():
    return [lambda x, i=i: i * x for i in range(5)]
    #          ^^^^  默认参数在循环每次迭代时求值，i 的值被固定

方式 2：functools.partial

python 复制代码

from functools import partial

def multiply(x, i):
    return i * x

def create_multipliers():
    return [partial(multiply, i) for i in range(5)]

方式 3：闭包嵌套（立即执行外层函数）

python 复制代码

def create_multipliers():
    def make_multiplier(i):
        return lambda x: i * x
    return [make_multiplier(i) for i in range(5)]

三种方式都正确输出：0 2 4 6 8

4. 组合起来：一个更隐蔽的例子

python 复制代码

def create_actions():
    actions = []
    for i in range(3):
        def action(item, cache=[]):  # 默认参数绑定 + 可变对象
            cache.append(item)
            return f"i={i}, cache={cache}"  # i 是延迟绑定的
        actions.append(action)
    return actions

actions = create_actions()
print(actions[0]("a"))  # i=2, cache=['a']  ❌ i 预期 0
print(actions[1]("b"))  # i=2, cache=['a', 'b']  ❌ 双重坑
print(actions[2]("c"))  # i=2, cache=['a', 'b', 'c']

同时踩了两个坑。修正后：

python 复制代码

def create_actions():
    actions = []
    for i in range(3):
        def action(item, cache=None):
            if cache is None:
                cache = []
            cache.append(item)
            return f"i={i}, cache={cache}"
        actions.append(action)
    return actions

嗯...这样也只修了可变参数坑，i 还是延迟绑定。需要两个一起修：

python 复制代码

def create_actions():
    actions = []
    for i in range(3):
        def action(item, cache=None, i=i):  # 同时解决两个坑
            if cache is None:
                cache = []
            cache.append(item)
            return f"i={i}, cache={cache}"
        actions.append(action)
    return actions

5. 避坑清单

python 复制代码

# ❌ 不要这样写
def process(data=[]):           # 可变默认参数
    ...

# ✅ 改成这样
def process(data=None):
    data = data or []           # 或严格判断：if data is None: data = []


# ❌ 不要在循环中直接创建闭包
funcs = [lambda: i for i in range(5)]

# ✅ 绑定当前值
funcs = [lambda i=i: i for i in range(5)]

6. 底层原理速记

概念	理解要点
函数定义时	`def` 语句执行时，默认参数对象被创建并绑定到函数对象上
函数调用时	未传参 → 复用绑定好的默认对象；传参 → 使用新对象
闭包（closure）	内层函数引用了外层函数的变量，形成闭包，变量本身被「捕获」而非值
LEGB 规则	闭包执行时按 Local → Enclosing → Global → Built-in 查找变量

简单记忆口诀：默认参数看定义时，闭包变量看执行时。

7. 总结

可变默认参数 ：[] {} set() 不要放参数默认值，用 None + 函数内部初始化
闭包延迟绑定 ：循环内创建闭包时，用 i=i 默认参数技巧固定当前值
两个坑同时出现时：逐个排查，各行其是地修
这些不是 bug，而是设计选择。理解它们后，你反而能利用这些特性写出更优雅的代码（比如缓存、参数绑定等）

这两个坑是 Python 开发者的「成人礼」。踩过，修过，才算是真正理解了 Python 的对象模型和作用域。