Python函数默认参数陷阱：可变对象的"共享"问题深度解析

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] = value
    return 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 = 0
    
    def 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 items

print(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] = value
    return info

print(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.count

print(count_calls_correct())  # 1
print(count_calls_correct())  # 1 ✅

五、为什么不可变对象没有这个问题？

因为不可变对象（如整数、字符串、元组）无法被修改，只能创建新对象，所以即使共享默认参数也不会有问题：

def add_num(x, y=10):  # y是不可变对象
    return x + y

print(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 "）

六、总结：避免陷阱的黄金法则

1. 永远不要将可变对象（列表、字典、集合、自定义实例等）作为函数默认参数
2. 标准解决方案：

   def function_name(param, mutable_default=None):
       if mutable_default is None:
           mutable_default = []  # 或 {}、Set()、自定义对象等
       # 函数逻辑...
   

3. 本质原因：默认参数在函数定义时创建，可变对象的默认值会在多次调用间保持状态

掌握这个知识点，能帮你避免Python开发中一个非常常见的"坑"，写出更可预测、更可靠的代码。记住：当看到函数默认参数是可变对象时，一定要提高警惕！