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

描述
Python的函数参数传递机制常被误解为"按值传递"或"按引用传递"，实际上采用的是"按共享传参"（Call by Sharing）。这种机制下，函数接收的是实参引用的副本，而非对象本身的副本。理解这一机制对避免常见的编程错误至关重要。

详细解析

1. 基本概念理解

• 按值传递：函数获得实参值的副本，修改不影响原始数据
• 按引用传递：函数获得实参的直接引用，修改直接影响原始数据
• 按共享传参：函数获得实参引用的副本，通过引用可以修改可变对象

2. 不可变对象的行为分析

def modify_number(x):
    print(f"传入的x的id: {id(x)}")
    x = x + 10  # 创建新对象
    print(f"修改后x的id: {id(x)}")
    return x

num = 5
print(f"原始num的id: {id(num)}")
result = modify_number(num)
print(f"函数外num的值: {num}")  # 输出: 5（未改变）
print(f"原始num的id未变: {id(num)}")

执行过程解析：

1. 函数调用时，x获得num引用的副本（指向同一个整数5）
2. x = x + 10创建新整数15，x重新绑定到新对象
3. 原始num仍指向整数5，不受影响

3. 可变对象的行为分析

def modify_list(lst):
    print(f"传入的lst的id: {id(lst)}")
    lst.append(4)  # 修改原对象
    lst = [7, 8, 9]  # 重新绑定
    print(f"重新绑定后lst的id: {id(lst)}")

my_list = [1, 2, 3]
print(f"原始my_list的id: {id(my_list)}")
modify_list(my_list)
print(f"函数外my_list: {my_list}")  # 输出: [1, 2, 3, 4]

关键点分析：

• lst.append(4)通过引用修改了原列表对象
• lst = [7, 8, 9]使形参lst指向新对象，不影响实参
• 实参my_list仍指向原列表，但内容已被修改

4. 默认参数的陷阱

def faulty_append(item, target=[]):
    target.append(item)
    return target

print(faulty_append(1))  # [1]
print(faulty_append(2))  # [1, 2]（非预期结果！）

def correct_append(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

原理说明：

• 默认参数在函数定义时求值一次
• 后续调用共享同一个列表对象
• 正确做法：使用None作为默认值，在函数内创建新对象

5. 函数参数传递的完整规则

步骤1：参数绑定

• 函数调用时，形参获得实参引用的副本
• 形参和实参指向同一个对象

步骤2：重新绑定与修改的区别

def demonstrate(x, y):
    # 重新绑定：不影响实参
    x = "new value"
    
    # 原地修改：影响可变对象的实参
    y.append("modified")

a = "original"
b = ["original"]
demonstrate(a, b)
print(a)  # "original"（未变）
print(b)  # ["original", "modified"]（已变）

步骤3：+=操作的特殊情况

def tricky_operation(x, y):
    x += 1      # 对不可变对象，相当于x = x + 1
    y += [4]    # 对可变对象，原地修改
    
num = 10
lst = [1, 2, 3]
tricky_operation(num, lst)
print(num)  # 10（未变）
print(lst)  # [1, 2, 3, 4]（已变）

6. 最佳实践与注意事项

避免意外的修改：

# 危险做法：可能意外修改传入的可变对象
def process_data(data):
    data.sort()  # 原地修改，影响原数据
    return data

# 安全做法：创建副本
def safe_process(data):
    data_copy = data.copy()  # 或list(data)
    data_copy.sort()
    return data_copy

明确传递意图：

• 文档说明函数是否会修改传入参数
• 对需要修改的情况，使用返回值或明确命名（如update_前缀）

7. 综合示例

def comprehensive_example(a, b, c=None):
    """演示各种参数传递情况"""
    print(f"初始: a={a}, b={b}, c={c}")
    
    # 不可变对象：重新绑定
    a = a * 2
    
    # 可变对象：可能修改原对象
    b.append("modified")
    
    # 默认参数处理
    if c is None:
        c = []
    c.append("new_item")
    
    return a, b, c

x = 10  # 不可变
y = ["original"]  # 可变
z = ["external"]  # 外部可变对象

result = comprehensive_example(x, y, z)
print(f"结果: {result}")
print(f"外部: x={x}, y={y}, z={z}")

输出分析：

• x保持不变（整数不可变）
• y被修改（列表原地修改）
• z被修改（通过参数传递直接修改）

通过这种循序渐进的解析，你可以清晰理解Python参数传递的本质，避免在实际编程中因误解而产生的错误。