默认参数的陷阱，每个Python新手都踩过

免费编程软件「python+pycharm」
链接：https://pan.quark.cn/s/48a86be2fdc0

一个让老程序员都翻过车的Bug

三年前，我在写一个电商系统的订单处理模块。

有个函数需要给商品添加标签，如果调用时没给标签列表，就自动新建一个空列表来装：

def add_tag(item, tags=[]): tags.append(item) return tags

看着没毛病吧？测试一下：

print(add_tag("电子产品")) # ['电子产品'] print(add_tag("包邮")) # ['电子产品', '包邮'] 等等，什么？ print(add_tag("今日特价")) # ['电子产品', '包邮', '今日特价']

我当时盯着屏幕看了十秒钟，脑子里只有一个念头：为什么第二次调用的结果里，还带着第一次的数据？

我期望的是每次不传tags时，都得到一个全新的空列表。但实际结果是，所有调用都共用同一个列表。

这还不是最离谱的。如果我把代码改一下：

def add_tag(item, tags=[]): tags.append(item) return tags def main(): user_tags = add_tag("电子产品") user_tags.append("高性价比") admin_tags = add_tag("包邮") print(admin_tags) # ['电子产品', '高性价比', '包邮'] main()

看到这个输出，我真的想砸键盘。

这个Bug花了两个小时才定位到。而原因说来很简单：Python的默认参数在函数定义时就被创建了，之后每次调用都用的同一个对象。

今天我把这个坑彻底讲清楚，包括它为什么会这样、会带来哪些隐藏问题，以及怎么正确地绕开它。

第一步：复现这个“灵异”现象

先写一个最简单的例子：

def surprise(x, data=[]): data.append(x) return data print(surprise(1)) # [1] print(surprise(2)) # [1, 2] print(surprise(3)) # [1, 2, 3]

每次调用，data都在累计之前传进去的值。

再看一个用字典的例子：

def collect(key, value, cache={}): cache[key] = value return cache print(collect("a", 1)) # {'a': 1} print(collect("b", 2)) # {'a': 1, 'b': 2}

同样的问题。

但如果你用不可变对象做默认参数，就没事：

def greet(name, suffix="先生"): return name + suffix print(greet("张")) # 张先生 print(greet("李")) # 李先生 —— 正常，每次都是新的"先生"

为什么字符串没问题，列表就有问题？

因为默认参数的值只计算一次，在函数定义时。

• suffix="先生"里的"先生"是字符串（不可变），你没法修改它，所以每次用都一样，也没机会出问题

• data=[]里的[]是列表（可变），每次调用函数时，如果你修改了这个列表，修改会保留到下一次调用

问题的本质是：默认参数不是“每次调用时创建新对象”，而是“在函数定义时创建一次对象，然后每次调用都复用这个对象”。

第二步：用id()看穿真相

id()函数可以返回对象的内存地址。我们来验证一下：

def show_id(x=[]): print(id(x)) return x print(id([])) # 随便创建一个空列表，看一个地址 show_id() # 地址A show_id() # 地址A（和上一次相同！） show_id() # 地址A（还是同一个）

三次调用，默认参数x指向的是同一个列表对象。

对比一下：

def good(x=None): if x is None: x = [] # 每次调用到这里才创建新列表 print(id(x)) good() # 地址B good() # 地址C（不同的地址）

看到了吗？x = []这行代码在函数体里，每次调用都会执行，所以每次都创建一个全新的列表。

而默认参数x=[]只执行一次——Python读代码时，遇到def这一行，就创建好了[]这个对象，存在某个地方，每次调用都拿过来用。

一句话：默认参数在def时创建，函数体里的代码在调用时执行。

第三步：为什么Python要这样设计？

你可能想问：这不是坑吗？Python为什么不设计成“每次调用重新创建默认参数”？

这个问题有技术上的原因，也有设计上的考量。

原因1：性能

函数定义只执行一次。如果每次调用都重新创建默认参数（即使是一个空列表），会带来不必要的开销。Python很注重简单场景下的性能。

原因2：一致性

Python的函数参数绑定机制是统一的。默认参数值在函数定义时被计算并保存，这个规则很简单一致。如果改成“每次调用重新计算”，会增加语言的复杂性。

原因3：这是一个特性，不是bug

Guido van Rossum（Python之父）认为这个行为是有用的。在某些场景下，你需要函数调用之间保持状态，这个特性可以方便地实现——比如一个带缓存的函数，可以把缓存字典作为默认参数。

def expensive_query(query, cache={}): if query in cache: return cache[query] result = do_real_query(query) # 耗时操作 cache[query] = result return result

这个代码利用了默认参数的持久性来缓存结果，下次用同样的query就能直接返回。

当然，这个技巧比较高级，普通开发者最好还是用更明确的方式（比如类或者闭包）。

所以准确地说：这不是设计缺陷，而是一个容易被误用的特性。

第四步：真实的Bug案例（比你想象的更隐蔽）

案例1：API请求参数累积

def fetch_data(url, params={}): params['timestamp'] = time.time() response = requests.get(url, params=params) return response

第一次调用，params是个空字典，加上timestamp后发给API。 第二次调用，params还是那个字典，里面已经有timestamp了，你又加了一个timestamp，变成了两个timestamp参数。API可能就懵了。

案例2：数据验证函数

def validate(data, errors=[]): if 'name' not in data: errors.append('缺少name字段') if 'age' not in data: errors.append('缺少age字段') return errors errors1 = validate({'name': '张三'}) errors2 = validate({'age': 18}) print(errors1) # ['缺少age字段'] print(errors2) # ['缺少age字段', '缺少name字段'] —— 混了

第二个调用的错误列表里，包含了第一次调用产生的错误。因为用的是同一个列表。

案例3：类实例化的坑

class Order: def __init__(self, items=[]): self.items = items order1 = Order() order1.items.append("手机") order2 = Order() print(order2.items) # ['手机'] —— 不是空列表！

这个坑尤其隐蔽。你想让每个订单都有自己独立的商品列表，结果所有订单都共享了同一个列表。

修复：

class Order: def __init__(self, items=None): if items is None: items = [] self.items = items

第五步：标准解法（None占位符）

正确的写法非常固定：

def good_function(param=None): if param is None: param = [] # 现在可以放心修改param了 param.append("something") return param

但要注意一个细节：如果调用方可能主动传入None作为合法值怎么办？

def process(data=None): if data is None: data = [] # 如果调用方传入None，也会被替换成空列表

如果你需要区分“没传参数”和“传了None”，可以这样做：

_sentinel = object() # 创建一个唯一的标识 def process(data=_sentinel): if data is _sentinel: data = [] # 只有没传参数时才创建新列表 # 如果调用方传了None，data就是None，不会被替换

这种写法很少用到，绝大多数场景用None占位符就够了。

为什么用None？

因为None是Python中表示“没有值”的标准方式。它不可变，安全，而且语义清晰。看到param=None，有经验的Python开发者立刻知道这是为了避免可变默认参数的陷阱。

什么类型需要这样做？

所有可变类型：

• 列表[]

• 字典{}

• 集合set()

• 自定义类的实例（如果会被修改）

• 任何可能在函数内部被修改的对象

不可变类型（字符串、整数、浮点数、元组、布尔值）不需要这个技巧，因为函数内部修改不了它们。

第六步：类型注解怎么写才规范？

现代Python有类型注解，和None默认值配合时有个常见的困惑：

def process(items: list = None) -> list: # 这样写对吗？ if items is None: items = [] items.append("x") return items

Pylance/Pyright可能会报警：None类型和list类型不匹配。

正确写法：

from typing import Optional, List def process(items: Optional[List] = None) -> List: if items is None: items = [] items.append("x") return items

Python 3.10+可以用更简洁的写法：

def process(items: list | None = None) -> list: if items is None: items = [] items.append("x") return items

用| None明确表示这个参数可以是None。

第七步：哪些函数内部可以安全地修改默认参数？

只有一种情况是安全的：你明确知道自己在做什么，并且是故意利用这个特性。

比如前面提到的缓存函数：

def memoize(func): cache = {} def wrapper(n): if n not in cache: cache[n] = func(n) return cache[n] return wrapper # 或者更直接的： def fibonacci(n, memo={}): if n in memo: return memo[n] if n <= 1: return n memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo) return memo[n]

这种情况下，你确实希望memo字典在调用之间保持状态。

但即使这样，更好的写法仍然是：

def fibonacci(n, memo=None): if memo is None: memo = {} if n in memo: return memo[n] # ... 其余代码相同

这样更清晰，也避免了副作用带来的困惑。

经验法则：除非有充分的理由（并且写清楚注释），否则永远用None占位符。

第八步：检查工具帮你自动发现问题

现代Python工具可以自动检测这个坑：

Pylint会警告：W0102: dangerous-default-value

Flake8通过插件可以检测

Pyright / mypy静态类型检查也能发现不一致

如果你用VSCode + Pylance，默认就有相关提示。

很多公司代码规范里明确规定：禁止使用可变对象作为默认参数。

一个完整的对比总结

# 错误写法 —— 会累积状态 def bad_append(item, target=[]): target.append(item) return target # 正确写法 —— 每次都重新创建 def good_append(item, target=None): if target is None: target = [] target.append(item) return target # 测试 print(bad_append(1)) # [1] print(bad_append(2)) # [1, 2] ← 出问题了 print(good_append(1)) # [1] print(good_append(2)) # [2] ← 正常

最后总结

这个坑的核心就一句话：

默认参数的值在函数定义时创建一次，之后每次调用都复用。

• 如果默认参数是可变对象（列表、字典、集合），你在函数内部修改它，修改会保留到下一次调用

• 这会导致非常隐蔽的bug，尤其是当你以为“每次调用都是新的”的时候

黄金法则：

永远不要用可变对象作为函数的默认参数。

正确做法：

def func(param=None): if param is None: param = [] # 或者 {} / set() # 现在可以放心修改param了

现在我写任何函数，只要参数有默认值，都会下意识地问自己：这个默认值可变吗？如果是列表、字典、集合，立刻改成None模式。

这个习惯救了我无数次。希望也能救你。