在Python中，理解参数传递机制对于编写正确的代码至关重要，特别是当传递可变对象时。下面我将详细分析传递可变对象的行为和内存机制。

1. Python的参数传递本质

Python中的参数传递是"对象引用传递"（或称为"按共享传递"）。这意味着：

• 传递的是对象的引用（内存地址），而不是对象本身的副本
• 对于不可变对象（如数字、字符串、元组），函数内修改不会影响原始对象
• 对于可变对象（如列表、字典、集合），函数内修改会影响原始对象

2. 传递可变对象的内存分析

示例1

：修改可变对象

def modify_list(lst):
    lst.append(4)  # 直接修改原列表
    print(f"函数内列表: {lst}, 内存地址: {id(lst)}")

my_list = [1, 2, 3]
print(f"原始列表: {my_list}, 内存地址: {id(my_list)}")
modify_list(my_list)
print(f"修改后列表: {my_list}, 内存地址: {id(my_list)}")

输出结果：

原始列表: [1, 2, 3], 内存地址: 140235678456000
函数内列表: [1, 2, 3, 4], 内存地址: 140235678456000
修改后列表: [1, 2, 3, 4], 内存地址: 140235678456000

内存示意图：

调用前:
my_list → [1, 2, 3](内存地址140235678456000)

调用时:
lst参数接收到my_list的引用，两者指向同一对象

修改后:
my_list和lst都指向 [1, 2, 3, 4](内存地址不变)

示例2：重新赋值可变对象

def reassign_list(lst):
    lst = [4, 5, 6]  # 创建新列表并赋值给局部变量lst
    print(f"函数内新列表: {lst}, 内存地址: {id(lst)}")

my_list = [1, 2, 3]
print(f"原始列表: {my_list}, 内存地址: {id(my_list)}")
reassign_list(my_list)
print(f"调用后列表: {my_list}, 内存地址: {id(my_list)}")

输出结果：

原始列表: [1, 2, 3], 内存地址: 140235678456000
函数内新列表: [4, 5, 6], 内存地址: 140235678456128
调用后列表: [1, 2, 3], 内存地址: 140235678456000

关键区别：

• append()等方法是原地修改，会影响原始对象
• 重新赋值(=)是创建新对象，不会影响原始对象

3. 常见可变对象传递场景

场景1：列表作为参数

def process_items(items):
    items.append('new')  # 修改会影响调用方
    items[0] = 'modified'  # 修改会影响调用方

shopping_list = ['apple', 'banana']
process_items(shopping_list)
print(shopping_list)  # ['modified', 'banana', 'new']

场景2：字典作为参数

def update_user(user):
    user['age'] += 1  # 修改会影响调用方
    user.setdefault('status', 'active')

user_data = {'name': 'Alice', 'age': 30}
update_user(user_data)
print(user_data)  # {'name': 'Alice', 'age': 31, 'status': 'active'}

场景3：集合作为参数

def add_to_set(s):
    s.add(4)  # 修改会影响调用方

numbers = {1, 2, 3}
add_to_set(numbers)
print(numbers)  # {1, 2, 3, 4}

4. 如何避免意外修改原始对象

如果不想函数内修改影响原始对象，可以：

方法1：显式创建副本

def safe_modify(lst):
    lst = lst.copy()  # 创建浅拷贝
    lst.append(4)
    return lst

original = [1, 2, 3]
new = safe_modify(original)
print(original)  # [1, 2, 3] (未改变)
print(new)      # [1, 2, 3, 4]

方法2：传递不可变副本

def safe_modify_dict(d):
    d = dict(d)  # 创建新字典
    d['new'] = 'value'
    return d

original_dict = {'a': 1}
new_dict = safe_modify_dict(original_dict)
print(original_dict)  # {'a': 1}
print(new_dict)      # {'a': 1, 'new': 'value'}

方法3：使用不可变类型

def process_data(data):
    # 元组是不可变的，无法修改
    data = data + (4,)  # 这会创建新元组
    return data

original_tuple = (1, 2, 3)
new_tuple = process_data(original_tuple)
print(original_tuple)  # (1, 2, 3)
print(new_tuple)      # (1, 2, 3, 4)

5. 深浅拷贝对参数传递的影响

对于嵌套的可变对象，需要注意深浅拷贝的区别：

import copy

def modify_nested(lst):
    # 浅拷贝：只拷贝最外层
    lst = copy.copy(lst)
    lst.append(3)           # 不影响原列表
    lst[0][0] = 'modified'  # 会影响原列表的内部列表
    
original = [[1, 2], ['a', 'b']]
modify_nested(original)
print(original)  # [['modified', 2], ['a', 'b']]

如果需要完全独立的副本，应该使用深拷贝：

def truly_independent_modify(lst):
    lst = copy.deepcopy(lst)
    lst[0][0] = 'changed'
    return lst

original = [[1, 2], ['a', 'b']]
new = truly_independent_modify(original)
print(original)  # [[1, 2], ['a', 'b']] (完全未改变)
print(new)      # [['changed', 2], ['a', 'b']]

6. 最佳实践建议

1. 明确函数契约：在文档中说明函数是否会修改输入参数
2. 防御性编程：如果不希望修改输入，函数内部应先创建副本
3. 优先返回新对象：而不是修改输入参数，除非有特殊需求
4. 注意嵌套结构：对于复杂数据结构，考虑使用deepcopy
5. 使用类型提示：明确参数和返回值的类型

from typing import List, Dict

def process_data(data: List[Dict]) -> List[Dict]:
    """处理数据并返回新列表，不修改输入"""
    data = copy.deepcopy(data)
    # 处理逻辑...
    return data

理解Python中可变对象的传递机制，可以帮助你避免许多常见的错误，特别是涉及数据意外修改的问题。