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

### Python 两大经典坑点：可变默认参数 & 闭包延迟绑定 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，而是设计选择。理解它们后，你反而能利用这些特性写出更优雅的代码（比如缓存、参数绑定等）