Python可变默认参数陷阱案例和解决方案

def create_counter(initial=0):
    """创建一个简单的计数器"""
    count = [initial]  # 使用列表来包装计数器值
    
    def increment():
        count[0] += 1
        return count[0]
    
    return increment

# 函数定义时发生了什么？
print("函数定义时: create_counter函数对象被创建")
print("默认参数initial=0被计算并存储")

def problematic_function(items=[]):
    """有问题的函数：使用可变默认参数"""
    items.append(len(items))
    return items

# 查看函数的默认参数存储
print("函数的__defaults__属性:", problematic_function.__defaults__)
print("默认参数的id:", id(problematic_function.__defaults__[0]))

# 多次调用函数
result1 = problematic_function()
print("第一次调用结果:", result1, "id:", id(result1))

result2 = problematic_function()
print("第二次调用结果:", result2, "id:", id(result2))

result3 = problematic_function()
print("第三次调用结果:", result3, "id:", id(result3))

print("\n问题显现：所有调用都返回同一个列表对象！")
print("result1 is result2:", result1 is result2)
print("result1 is result3:", result1 is result3)

import dis

def analyze_function(func):
    """分析函数的字节码"""
    print(f"\n分析函数: {func.__name__}")
    print("=" * 50)
    dis.dis(func)
    
    # 查看co_consts（常量池）
    print(f"\n函数常量池 (co_consts): {func.__code__.co_consts}")
    
    # 查看默认参数值
    if func.__defaults__:
        print(f"默认参数值 (__defaults__): {func.__defaults__}")
        for i, default in enumerate(func.__defaults__):
            print(f"  参数{i}: {default} (id: {id(default)})")

# 分析有问题的函数
analyze_function(problematic_function)

# 对比：分析使用不可变默认参数的函数
def safe_function(count=0):
    """安全的函数：使用不可变默认参数"""
    count += 1
    return count

analyze_function(safe_function)

def get_cached_data(key, cache={}):
    """有问题的缓存实现：所有调用共享同一个cache字典"""
    if key in cache:
        print(f"缓存命中: {key}")
        return cache[key]
    
    # 模拟昂贵的计算
    print(f"计算: {key}")
    result = f"result_for_{key}"
    cache[key] = result
    return result

# 测试缓存函数
print("=== 测试有问题的缓存函数 ===")
print("第一次调用 get_cached_data('a'):", get_cached_data('a'))
print("第二次调用 get_cached_data('a'):", get_cached_data('a'))
print("第三次调用 get_cached_data('b'):", get_cached_data('b'))

# 问题：不同的调用者会共享cache！
print("\n=== 模拟不同调用者 ===")
def caller1():
    return get_cached_data('x')

def caller2():
    return get_cached_data('x')

print("caller1调用结果:", caller1())
print("caller2调用结果（意外命中缓存）:", caller2())

# 查看缓存内容
print("\n缓存内容:", problematic_function.__defaults__[0] if problematic_function.__defaults__ else "无")

def create_user(name, permissions=[]):
    """创建用户并分配权限"""
    user = {
        'name': name,
        'permissions': permissions
    }
    return user

print("=== 测试用户创建函数 ===")

# 创建多个用户
user1 = create_user('Alice')
user1['permissions'].append('read')  # 只为Alice添加read权限

user2 = create_user('Bob')
user2['permissions'].append('write')  # 本意是为Bob添加write权限

user3 = create_user('Charlie')

print(f"user1: {user1}")
print(f"user2: {user2}")
print(f"user3: {user3}")

print("\n灾难：所有用户的permissions都变成了['read', 'write']！")
print("user1['permissions'] is user2['permissions']:", 
      user1['permissions'] is user2['permissions'])

def create_matrix(rows=3, cols=3, default_value=0, matrix=None):
    """
    创建矩阵的复杂示例
    问题：多层嵌套的默认参数
    """
    if matrix is None:
        matrix = []
    
    for i in range(rows):
        row = []
        for j in range(cols):
            row.append(default_value)
        matrix.append(row)
    
    return matrix

print("=== 测试矩阵创建函数 ===")

# 第一次调用
matrix1 = create_matrix(2, 2, 1)
print("matrix1 (2x2, 默认值1):", matrix1)

# 修改matrix1
matrix1[0][0] = 99
print("修改后 matrix1:", matrix1)

# 第二次调用，使用默认参数
matrix2 = create_matrix(2, 2, 2)
print("matrix2 (2x2, 默认值2):", matrix2)

print("\n意外：matrix2受到了matrix1修改的影响！")
print("原因：默认参数matrix=[]在所有调用间共享")

def safe_function_with_list(items=None):
    """安全的函数：使用None作为默认值"""
    if items is None:
        items = []  # 每次调用创建新的列表
    
    items.append(len(items))
    return items

print("=== 使用None作为默认值 ===")

# 多次调用测试
results = []
for i in range(3):
    result = safe_function_with_list()
    results.append(result)
    print(f"调用{i+1}: {result} (id: {id(result)})")

# 验证每个结果都是不同的对象
print("\n所有结果都是不同的对象:")
for i in range(len(results)):
    for j in range(i+1, len(results)):
        print(f"  result{i} is result{j}: {results[i] is results[j]}")

# 测试传入自定义列表的情况
custom_list = [10, 20]
result = safe_function_with_list(custom_list)
print(f"\n传入自定义列表: {result}")
print(f"原列表也被修改: {custom_list}")

# 创建一个唯一的哨兵对象
_SENTINEL = object()

def advanced_safe_function(items=_SENTINEL):
    """
    使用唯一哨兵对象作为默认值
    优点：允许None作为合法参数值
    """
    if items is _SENTINEL:
        items = []
    
    items.append(len(items))
    return items

print("=== 使用唯一哨兵对象 ===")

# 测试None作为参数
print("传入None:", advanced_safe_function(None))
print("使用默认值:", advanced_safe_function())
print("传入空列表:", advanced_safe_function([]))

# 验证哨兵对象的唯一性
print(f"\n哨兵对象id: {id(_SENTINEL)}")
print(f"是否唯一: {_SENTINEL is object()}")

from functools import wraps
import inspect

def sanitize_defaults(func):
    """
    装饰器：自动处理可变默认参数
    将可变默认参数替换为None
    """
    # 获取函数签名
    sig = inspect.signature(func)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 绑定参数
        bound_args = sig.bind(*args, **kwargs)
        bound_args.apply_defaults()
        
        # 检查并处理可变默认参数
        for param_name, param in sig.parameters.items():
            if param_name in bound_args.arguments:
                default =