Python中的函数参数传递机制：可变对象与不可变对象的区别

知识点描述
在Python中，函数参数传递机制经常被误解为"值传递"或"引用传递"。实际上，Python采用"对象引用传递"机制，其核心区别在于传递的是可变对象还是不可变对象的引用。理解这一机制对于避免常见的编程错误至关重要。

详细讲解

第一步：理解Python的变量本质
在Python中，变量实际上是对象的引用（标签），而不是存储数据的容器本身。

a = 10  # a是对整数对象10的引用
b = [1, 2, 3]  # b是对列表对象[1, 2, 3]的引用

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

• 不可变对象：创建后不能被修改的对象

  • 数字（int, float, complex）
  • 字符串（str）
  • 元组（tuple）
  • 布尔值（bool）
  • frozenset

• 可变对象：创建后可以被修改的对象

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

第三步：参数传递的基本原理
Python函数参数传递的是对象的引用（内存地址），而不是对象本身的副本。

def test_func(x):
    print(f"函数内x的id: {id(x)}")

value = 100
print(f"函数外value的id: {id(value)}")
test_func(value)  # 传递的是同一个对象的引用

第四步：不可变对象参数传递的详细分析

def modify_immutable(num, text):
    print(f"修改前 - num的id: {id(num)}, text的id: {id(text)}")
    num = 200  # 创建新的整数对象
    text = "修改后的文本"  # 创建新的字符串对象
    print(f"修改后 - num的id: {id(num)}, text的id: {id(text)}")
    return num, text

original_num = 100
original_text = "原始文本"
print(f"调用前 - original_num的id: {id(original_num)}, original_text的id: {id(original_text)}")

result_num, result_text = modify_immutable(original_num, original_text)

print(f"调用后 - original_num: {original_num}, original_text: {original_text}")
print(f"返回值 - result_num: {result_num}, result_text: {result_text}")

执行过程分析：

1. 函数调用时，num和text参数获得与原始变量相同的对象引用
2. 在函数内部对不可变对象重新赋值时，实际上是创建了新对象
3. 原始变量仍然指向原来的对象，因此不受影响

第五步：可变对象参数传递的详细分析

def modify_mutable(lst, dct):
    print(f"修改前 - lst的id: {id(lst)}, dct的id: {id(dct)}")
    
    # 直接修改可变对象的内容
    lst.append(4)  # 修改列表内容
    dct["new_key"] = "new_value"  # 修改字典内容
    
    # 重新赋值（创建新对象）
    lst = [10, 20, 30]  # 这不会影响外部变量
    dct = {"completely": "different"}
    
    print(f"修改后 - lst的id: {id(lst)}, dct的id: {id(dct)}")
    return lst, dct

original_list = [1, 2, 3]
original_dict = {"key": "value"}
print(f"调用前 - original_list的id: {id(original_list)}, original_dict的id: {id(original_dict)}")

result_list, result_dict = modify_mutable(original_list, original_dict)

print(f"调用后 - original_list: {original_list}")  # 被修改了！
print(f"调用后 - original_dict: {original_dict}")  # 被修改了！
print(f"返回值 - result_list: {result_list}")

关键理解点：

1. 对可变对象内容的修改会影响原始对象
2. 对参数重新赋值只会影响函数内的局部变量
3. 函数返回时，重新赋值的对象不会影响原始参数

第六步：实际应用中的常见陷阱

# 陷阱1：误以为不会修改原始列表
def bad_append(item, target_list=[]):  # 默认参数在函数定义时创建
    target_list.append(item)
    return target_list

list1 = bad_append(1)  # [1]
list2 = bad_append(2)  # [1, 2] - 意外结果！

# 正确做法
def good_append(item, target_list=None):
    if target_list is None:
        target_list = []
    target_list.append(item)
    return target_list

# 陷阱2：试图在函数内修改不可变对象
def increment_number(num):
    num += 1  # 这不会影响外部变量
    return num

x = 5
increment_number(x)
print(x)  # 仍然是5，不是6

# 正确做法
x = increment_number(x)  # 需要接收返回值

第七步：总结与最佳实践

1. 参数传递本质：Python传递的是对象引用（按共享传参）
2. 不可变对象：函数内修改会创建新对象，不影响原始变量
3. 可变对象：函数内修改内容会影响原始对象
4. 最佳实践：
   • 避免在函数内意外修改传入的可变对象
   • 需要修改时，明确文档说明或创建副本
   • 使用返回值来传递修改结果

# 安全的函数设计
def process_data(data):
    # 创建副本以避免修改原始数据
    data_copy = data.copy() if hasattr(data, 'copy') else data[:]
    # 处理副本
    data_copy.process()
    return data_copy

理解这一机制有助于编写更可预测、更安全的Python代码。