Python值传递与引用传递的区别详解 | Python参数传递机制

Python参数传递的本质

在Python中，所有参数传递都是"对象引用传递"。这意味着传递给函数的是对象的引用（内存地址），而不是对象本身的副本。然而，根据对象类型（可变或不可变），函数内对参数的操作会产生不同的结果：

不可变对象（数字、字符串、元组）：函数内修改会创建新对象，不影响原始对象
可变对象（列表、字典、集合）：函数内修改会影响原始对象

不可变对象示例（类似值传递）

当传递不可变对象时，函数内部对参数的修改不会影响原始变量，因为操作会创建新对象：


def modify_number(x):
    print("函数内 - 修改前:", x, id(x))
    x = x + 10  # 创建新对象
    print("函数内 - 修改后:", x, id(x))

num = 5
print("调用前:", num, id(num))
modify_number(num)
print("调用后:", num, id(num))  # 原始值未改变

输出结果分析：

调用前: 5 140719415175744

函数内 - 修改前: 5 140719415175744

函数内 - 修改后: 15 140719415176064

调用后: 5 140719415175744

关键点： 函数内部修改创建了新整数对象，原始变量保持不变。内存地址变化证明创建了新对象。

可变对象示例（类似引用传递）

当传递可变对象时，函数内部对参数的修改会影响原始对象：


def modify_list(lst):
    print("函数内 - 修改前:", lst, id(lst))
    lst.append(4)      # 修改原列表
    lst[0] = 99        # 修改原列表
    print("函数内 - 修改后:", lst, id(lst))

my_list = [1, 2, 3]
print("调用前:", my_list, id(my_list))
modify_list(my_list)
print("调用后:", my_list, id(my_list))  # 原始列表被修改

输出结果分析：

调用前: [1, 2, 3] 140258147731648

函数内 - 修改前: [1, 2, 3] 140258147731648

函数内 - 修改后: [99, 2, 3, 4] 140258147731648

调用后: [99, 2, 3, 4] 140258147731648

关键点： 函数内部修改影响了原始列表。所有操作使用相同内存地址，证明操作的是同一个对象。

重新赋值与就地修改的区别

理解重新赋值和就地修改的区别至关重要，这解释了为什么有时可变对象也不会被修改：


def reassign_list(lst):
    print("函数内 - 重新赋值前:", lst, id(lst))
    lst = [10, 20, 30]  # 创建新列表对象
    print("函数内 - 重新赋值后:", lst, id(lst))

def modify_list_inplace(lst):
    print("函数内 - 修改前:", lst, id(lst))
    lst.append(100)     # 就地修改原列表
    print("函数内 - 修改后:", lst, id(lst))

original_list = [1, 2, 3]

print("=== 重新赋值示例 ===")
print("调用前:", original_list, id(original_list))
reassign_list(original_list)
print("调用后:", original_list, id(original_list))  # 原始列表不变

print("\n=== 就地修改示例 ===")
print("调用前:", original_list, id(original_list))
modify_list_inplace(original_list)
print("调用后:", original_list, id(original_list))  # 原始列表被修改

关键区别：

重新赋值 (=操作) 会创建新对象，断开与原始对象的联系
就地修改 (append, extend, 直接元素赋值等) 会修改原始对象
内存地址变化表明创建了新对象，内存地址不变表明修改原对象

Python中的对象分类

不可变对象

数字类型：int, float, complex
字符串：str
字节：bytes
元组：tuple
布尔：bool
冻结集合：frozenset

函数内修改会创建新对象，原始对象不变

可变对象

列表：list
字典：dict
集合：set
字节数组：bytearray
用户自定义类实例

函数内就地修改会影响原始对象

实际应用建议

最佳实践

需要避免函数修改原始数据时，使用不可变对象
需要修改原始数据时，使用可变对象
不想修改原始可变对象时，创建副本：
- new_list = old_list.copy()
- new_dict = old_dict.copy()
- new_set = old_set.copy()
- 使用copy.deepcopy()处理嵌套对象
在函数文档中明确说明是否会修改传入的参数

示例：安全地处理列表


def safe_modify(data):
    """处理列表数据但不修改原始列表"""
    # 创建副本进行操作
    working_copy = data.copy()
    working_copy.append("安全修改")
    working_copy[0] = 100
    return working_copy

original = [1, 2, 3]
result = safe_modify(original)
print("原始列表:", original)  # [1, 2, 3]
print("处理结果:", result)    # [100, 2, 3, '安全修改']

总结：Python参数传递机制

关键点	说明
传递机制	对象引用传递（传递内存地址）
不可变对象	类似值传递效果（函数内修改创建新对象）
可变对象	类似引用传递效果（函数内就地修改影响原对象）
重新赋值	创建新对象，不影响原始对象
最佳实践	根据需求选择对象类型，需要保护原始数据时使用副本