90%的Python程序员不知道，函数参数传递中可变对象的修改竟会导致意想不到的副作用！

一、参数传递的本质：对象引用传递

在Python中，所有参数传递都是对象引用的传递。这意味着函数调用时传递的不是对象本身，而是指向对象的引用。理解这一点是掌握参数传递内存行为的关键。

def modify_data(a, b):
    a = 100       # 重新赋值
    b.append(10)  # 修改原对象

n1 = 11           # 不可变对象（整数）
n2 = [22, 33, 44] # 可变对象（列表）

modify_data(n1, n2)

二、不可变对象：函数内的修改不影响原始值

典型不可变对象：

• 整数（int）
• 浮点数（float）
• 字符串（str）
• 元组（tuple）

内存行为分析：

关键发现：

• 函数内对不可变对象重新赋值时，会创建新对象
• 原始对象的引用计数不受影响
• 函数调用结束后，原始变量值保持不变

三、可变对象：函数内的修改影响原始值

典型可变对象：

• 列表（list）
• 字典（dict）
• 集合（set）
• 自定义对象

关键发现：

• 函数内对可变对象的修改直接影响原始对象
• 所有指向该对象的引用都会"看到"变更
• 这种特性可能导致意想不到的副作用

四、实战调试：透视内存变化

使用VS Code调试器观察参数传递的内存行为：

1. 在函数调用处设置断点
2. 启动调试模式（点击"小虫子"图标）
3. 使用"单步进入"（Step Into）功能
4. 观察变量窗口中的变化：

def fun(arg1, arg2):
    print(arg1)      # 11
    print(arg2)      # [22, 33, 44]
    arg1 = 100       # 创建新整数对象
    arg2.append(10)  # 修改原列表
    print(arg1)      # 100
    print(arg2)      # [22, 33, 44, 10]

n1 = 11
n2 = [22, 33, 44]

print("调用前:", n1, n2)  # 11, [22,33,44]
fun(n1, n2)
print("调用后:", n1, n2)  # 11, [22,33,44,10]

调试观察重点：

• 不可变对象（n1）在函数内赋值时的内存地址变化
• 可变对象（n2）在函数内修改时的内存地址不变
• 函数返回后原始变量的状态

五、黄金法则：避免参数传递陷阱

1. 使用不可变对象作为默认值

# 错误做法：默认值为可变对象
def add_item(item, items=[]):
    items.append(item)
    return items

# 正确做法：默认值为None
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

2. 需要修改时创建副本

def process_data(data):
    # 创建列表副本
    data = data.copy()
    # 安全修改操作
    data.append(100)
    return data

3. 明确函数行为

在文档字符串中明确说明函数是否会修改输入参数：

def update_user(user: dict) -> None:
    """
    修改用户信息（会直接修改传入的字典）
    
    参数:
    user: 要修改的用户字典（会被直接修改）
    """
    user['last_updated'] = datetime.now()

六、实际应用场景

适用不可变对象：

• 配置参数
• 常量值
• 不会改变的基准数据

适用可变对象：

• 需要就地修改的大型数据集
• 逐步收集结果的容器
• 缓存对象

# 不可变对象：安全传递
def calculate_tax(price, tax_rate=0.08):
    return price * (1 + tax_rate)

# 可变对象：高效处理大数据
def process_batch(data_batch):
    # 直接修改大数据集，避免复制开销
    data_batch.clean()
    data_batch.normalize()
    return data_batch

掌握Python参数传递的精髓

理解可变对象与不可变对象在参数传递中的差异，是成为Python高级开发者的关键一步。记住这个核心原则："不可变对象传值，可变对象传引用" - 虽然不完全准确，但是实用的记忆口诀

立即挑战：

def mystery_func(a, b):
    a = a * 2
    b.append(a)
    return b

x = 10
y = [20]
result = mystery_func(x, y)

# 问题：x, y, result 的值分别是什么？