Python函数默认参数陷阱：可变对象的"共享"问题深度解析
在Python中，函数默认参数的处理方式有一个容易被忽略的特性，尤其是当默认参数是可变对象时，很容易引发意想不到的问题。今天我们通过多个实例，彻底搞懂这个知识点。
一、核心问题：可变对象作为默认参数的意外行为
先看最经典的列表示例，这是理解问题的基础：
# 错误示例：列表作为默认参数
def add_item_wrong(item, items=[]):items.append(item)return items# 第一次调用：使用默认空列表
print(add_item_wrong("apple")) # 预期 ['apple']，实际 ['apple']# 第二次调用：仍然使用默认参数
print(add_item_wrong("banana")) # 预期 ['banana']，实际 ['apple', 'banana'] ❌
为什么会这样？因为默认参数在函数定义时就被创建，而非每次调用时。所有调用共享同一个列表对象！
二、更多实例：不同可变对象的相同陷阱
这个问题不仅存在于列表，所有可变对象都会遇到同样的问题：
实例1：字典作为默认参数
def add_info_wrong(key, value, info={}):info[key] = valuereturn info# 第一次调用
print(add_info_wrong("name", "Alice")) # {'name': 'Alice'}# 第二次调用
print(add_info_wrong("age", 30)) # {'name': 'Alice', 'age': 30} ❌
# 预期：只包含新添加的age信息，实际却保留了之前的name信息
实例2：集合作为默认参数
def add_to_set_wrong(element, elements=set()):elements.add(element)return elements# 第一次调用
print(add_to_set_wrong(1)) # {1}# 第二次调用
print(add_to_set_wrong(2)) # {1, 2} ❌
# 预期：{2}，实际却包含了之前添加的1
实例3：自定义类的实例作为默认参数
class Counter:def __init__(self):self.count = 0def increment(self):self.count += 1# 错误示例：自定义对象作为默认参数
def count_calls_wrong(counter=Counter()):counter.increment()return counter.count# 第一次调用
print(count_calls_wrong()) # 1# 第二次调用
print(count_calls_wrong()) # 2 ❌
# 预期：1，实际却记住了之前的计数
三、问题根源：默认参数的创建时机
通过函数的__defaults__属性，我们可以清晰看到默认参数的创建和变化：
def demo(default=[]):default.append(1)return default# 函数定义后，查看默认参数
print("定义后:", demo.__defaults__) # 输出: ([],)# 第一次调用后
demo()
print("第一次调用后:", demo.__defaults__) # 输出: ([1],)# 第二次调用后
demo()
print("第二次调用后:", demo.__defaults__) # 输出: ([1, 1],)
关键结论：
- 默认参数在函数定义时创建，存储在函数对象中
- 对于可变对象，所有函数调用都会共享这个默认对象
- 每次修改都会影响到这个共享对象
四、通用解决方案：用None作为默认值
解决这类问题的标准模式是：用None作为默认参数，在函数内部创建可变对象。
针对列表的正确实现
def add_item_correct(item, items=None):if items is None: # 如果未传入参数items = [] # 每次调用都创建新列表items.append(item)return itemsprint(add_item_correct("apple")) # ['apple']
print(add_item_correct("banana")) # ['banana'] ✅
针对字典的正确实现
def add_info_correct(key, value, info=None):if info is None:info = {} # 每次调用创建新字典info[key] = valuereturn infoprint(add_info_correct("name", "Alice")) # {'name': 'Alice'}
print(add_info_correct("age", 30)) # {'age': 30} ✅
针对自定义对象的正确实现
def count_calls_correct(counter=None):if counter is None:counter = Counter() # 每次调用创建新计数器counter.increment()return counter.countprint(count_calls_correct()) # 1
print(count_calls_correct()) # 1 ✅
五、为什么不可变对象没有这个问题？
因为不可变对象（如整数、字符串、元组）无法被修改，只能创建新对象，所以即使共享默认参数也不会有问题：
def add_num(x, y=10): # y是不可变对象return x + yprint(add_num(5)) # 15
print(add_num(5)) # 15（结果始终正确）
当我们尝试"修改"不可变对象时，实际上是创建了新对象，不会影响默认参数：
def modify_str(s, prefix="Hello "):return prefix + s # 创建新字符串，不影响默认参数print(modify_str("Alice")) # "Hello Alice"
print(modify_str("Bob")) # "Hello Bob"（默认参数始终是"Hello "）
六、总结：避免陷阱的黄金法则
- 永远不要将可变对象（列表、字典、集合、自定义实例等）作为函数默认参数
- 标准解决方案：
def function_name(param, mutable_default=None):if mutable_default is None:mutable_default = [] # 或 {}、Set()、自定义对象等# 函数逻辑... - 本质原因：默认参数在函数定义时创建，可变对象的默认值会在多次调用间保持状态
掌握这个知识点，能帮你避免Python开发中一个非常常见的"坑"，写出更可预测、更可靠的代码。记住：当看到函数默认参数是可变对象时，一定要提高警惕！