Python中的函数参数传递机制：可变参数与不可变参数的行为差异

题目描述：
在Python中，函数参数的传递方式经常让初学者困惑。当传递不可变对象（如整数、字符串、元组）和可变对象（如列表、字典）作为参数时，函数内部对参数的操作会产生不同的结果。请详细解释Python的函数参数传递机制，并通过示例说明可变和不可变参数的行为差异。

知识讲解：

第一步：理解Python的变量和对象关系

• Python中变量是对象的引用（标签），而不是存储数据的容器
• 每个对象都有身份（id）、类型（type）和值（value）
• 赋值操作 a = 1 实际上是让变量a引用值为1的整数对象

第二步：区分可变与不可变对象

• 不可变对象：创建后不能修改内容，如int、float、str、tuple

a = 1      # 整数不可变
b = "hello" # 字符串不可变
c = (1, 2)  # 元组不可变

• 可变对象：创建后可以修改内容，如list、dict、set

x = [1, 2]  # 列表可变
y = {'a': 1} # 字典可变

第三步：参数传递的本质是"传对象引用"

• Python函数参数传递既不是传值也不是传引用，而是传递对象的引用
• 函数调用时，实参的引用被复制给形参
• 两个引用指向同一个对象

第四步：不可变参数的行为分析

def modify_immutable(x):
    print(f"函数内修改前: id(x) = {id(x)}")
    x = x + 10  # 创建新对象，重新绑定
    print(f"函数内修改后: id(x) = {id(x)}")
    return x

a = 5
print(f"调用前: id(a) = {id(a)}")
result = modify_immutable(a)
print(f"调用后: a = {a}")  # 输出5，原变量未改变
print(f"调用后: id(a) = {id(a)}")  # id不变

执行过程详解：

1. 调用函数时，实参a的引用复制给形参x，x和a指向同一个整数5
2. 执行x = x + 10时，由于整数不可变，Python创建新对象15
3. 形参x重新绑定到新对象15，但实参a仍然指向原对象5
4. 函数外部变量a不受影响

第五步：可变参数的行为分析

def modify_mutable(lst):
    print(f"函数内修改前: id(lst) = {id(lst)}")
    lst.append(4)  # 原地修改，不创建新对象
    print(f"函数内修改后: id(lst) = {id(lst)}")

my_list = [1, 2, 3]
print(f"调用前: id(my_list) = {id(my_list)}")
modify_mutable(my_list)
print(f"调用后: my_list = {my_list}")  # 输出[1, 2, 3, 4]，原列表被修改
print(f"调用后: id(my_list) = {id(my_list)}")  # id不变

执行过程详解：

1. 调用函数时，实参my_list的引用复制给形参lst，两者指向同一个列表对象
2. 执行lst.append(4)时，由于列表可变，直接在原对象上修改
3. 没有创建新对象，所有引用该对象的变量都能看到变化
4. 函数外部变量my_list指向的对象内容被改变

第六步：特殊情况分析 - 重新绑定可变参数

def rebind_mutable(lst):
    print(f"重新绑定前: id(lst) = {id(lst)}")
    lst = [4, 5, 6]  # 重新绑定到新对象
    print(f"重新绑定后: id(lst) = {id(lst)}")

my_list = [1, 2, 3]
print(f"调用前: id(my_list) = {id(my_list)}")
rebind_mutable(my_list)
print(f"调用后: my_list = {my_list}")  # 输出[1, 2, 3]，未被修改

关键区别：

• 使用原地操作（如append、extend）会修改原对象
• 使用赋值操作（=）会创建新对象并重新绑定形参，不影响实参

第七步：实际应用建议

1. 如果不想修改原可变对象，在函数内先创建副本：

def safe_modify(lst):
    new_lst = lst.copy()  # 或list(lst)或lst[:]
    new_lst.append(100)
    return new_lst

2. 明确函数的文档字符串，说明是否会修改传入参数

总结：
Python参数传递是"传递对象引用"，行为差异取决于对象的可变性：

• 不可变对象：函数内修改会创建新对象，不影响实参
• 可变对象：函数内原地修改会影响实参，重新绑定不会影响实参
  理解这一机制对编写正确的Python程序至关重要。