Python中的函数参数传递机制：按共享传参（Call by Sharing）

描述
在Python中，函数参数传递机制常被误解为"按值传递"或"按引用传递"，但实际上Python采用的是"按共享传参"（Call by Sharing）。这种机制下，函数接收的是实参的引用副本，而不是值的副本或原始引用本身。这意味着函数内部可以修改可变对象的内容，但不能重新绑定外部变量。

关键概念

1. 变量是对象的引用标签，不是存储数据的容器
2. 函数调用时传递的是对象的引用副本
3. 可变对象（列表、字典等）的内容可以被修改
4. 不可变对象（数字、字符串、元组等）不能被修改
5. 重新赋值参数只会影响函数内部的局部引用

详细解析过程

步骤1：理解变量与对象的关系

a = [1, 2, 3]  # 变量a引用列表对象[1, 2, 3]
b = a         # 变量b引用同一个列表对象

• 变量a和b都是指向同一个列表对象的引用标签
• 修改列表内容会影响所有引用该列表的变量

步骤2：基本参数传递示例

def modify_list(lst):
    print(f"函数内初始id: {id(lst)}")  # 与外部列表id相同
    lst.append(4)  # 修改可变对象的内容
    print(f"修改后id: {id(lst)}")      # id保持不变

my_list = [1, 2, 3]
print(f"函数外初始id: {id(my_list)}")
modify_list(my_list)
print(f"最终结果: {my_list}")  # 输出: [1, 2, 3, 4]

• 函数接收的是外部列表对象的引用副本
• 修改列表内容会影响原始对象
• 对象的id在函数内外保持一致，证明是同一个对象

步骤3：重新赋值参数的陷阱

def reassign_list(lst):
    print(f"重新赋值前id: {id(lst)}")
    lst = [4, 5, 6]  # 重新绑定局部引用
    print(f"重新赋值后id: {id(lst)}")
    print(f"函数内: {lst}")

my_list = [1, 2, 3]
print(f"函数外初始id: {id(my_list)}")
reassign_list(my_list)
print(f"函数外: {my_list}")  # 输出: [1, 2, 3]，未改变！

• lst = [4, 5, 6]创建了新列表，将局部引用lst重新绑定到新对象
• 这不会影响外部变量my_list的引用关系
• 体现了"引用副本"的特性

步骤4：不可变对象的行为

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

num = 10
print(f"函数外初始id: {id(num)}")
result = modify_number(num)
print(f"原始num: {num}")    # 输出: 10，未改变
print(f"返回结果: {result}") # 输出: 11

• 整数是不可变对象，x + 1创建了新对象
• 函数内的重新绑定不影响外部变量
• 体现了不可变对象在参数传递中的行为

步骤5：默认参数的特殊情况

def append_to_list(item, lst=[]):  # 默认参数在定义时求值
    lst.append(item)
    return lst

print(append_to_list(1))  # 输出: [1]
print(append_to_list(2))  # 输出: [1, 2] 而不是 [2]！

• 默认参数在函数定义时创建，不是每次调用时创建
• 所有调用共享同一个默认列表对象
• 这是按共享传参的一个常见陷阱

正确做法：

def append_to_list_correct(item, lst=None):
    if lst is None:  # 每次调用创建新列表
        lst = []
    lst.append(item)
    return lst

步骤6：实际应用技巧

1. 需要修改外部变量时：返回新值或修改可变对象

# 方法1：返回新值
def square_numbers(nums):
    return [x**2 for x in nums]

# 方法2：修改可变对象
def square_numbers_inplace(nums):
    for i in range(len(nums)):
        nums[i] = nums[i]**2

2. 避免意外修改：使用拷贝

def safe_modify(lst):
    lst = lst.copy()  # 创建副本
    lst.append("modified")
    return lst

总结
Python的按共享传参机制既不是纯粹的按值传递，也不是按引用传递。理解这种机制的关键在于：

• 变量是对象的引用标签
• 函数接收引用副本，可以修改共享对象但不能重新绑定外部变量
• 可变对象的内容可修改，不可变对象只能创建新对象
• 默认参数在定义时求值，可能产生意外共享

这种机制使得Python在保持简洁语法的同时，提供了灵活的对象操作能力。