在python编程中，理解对象的“可变性”（mutability）和“不可变性”（immutability）至关重要，尤其是在处理数据结构如字典和列表时。当我们将一个对象赋值给变量或将其存储在数据结构中时，我们实际上存储的是对该对象在内存中的“引用”（reference），而不是对象本身的副本。
可变对象与不可变对象
Python中的数据类型可以分为两大类：
- 不可变对象 (Immutable Objects)：一旦创建，其值就不能被改变。例如：整数（int）、浮点数（float）、字符串（str）、元组（tuple）。当你对一个不可变对象进行“修改”操作时，实际上是创建了一个新的对象并改变了变量的引用。
- 可变对象 (Mutable Objects)：创建后，其值可以被修改。例如：列表（list）、字典（dict）、集合（set）。对可变对象的修改会直接作用于内存中的原始对象，所有引用该对象的变量都会看到这些变化。
问题分析：列表值意外变化的根源
考虑以下代码片段，它尝试构建一个字典，其中键是整数，值是随迭代增长的列表：
dict_problematic = {}
current_list = []
for i in range(3):
current_list.append(i)
dict_problematic.update({i: current_list}) # 问题所在：直接引用了 current_list
print(f"迭代 {i}: current_list = {current_list}, dict_problematic = {dict_problematic}")
print("\n最终结果:")
print(dict_problematic)运行上述代码，你将观察到以下输出：
迭代 0: current_list = [0], dict_problematic = {0: [0]}
迭代 1: current_list = [0, 1], dict_problematic = {0: [0, 1], 1: [0, 1]}
迭代 2: current_list = [0, 1, 2], dict_problematic = {0: [0, 1, 2], 1: [0, 1, 2], 2: [0, 1, 2]}
最终结果:
{0: [0, 1, 2], 1: [0, 1, 2], 2: [0, 1, 2]}可以看到，最终字典中所有的值都变成了[0, 1, 2]，而不是我们期望的{0: [0], 1: [0, 1], 2: [0, 1, 2]}。这是因为在dict_problematic.update({i: current_list})这行代码中，字典存储的并不是current_list在当前迭代时的“快照”，而是对current_list这个列表对象的引用。由于current_list是一个可变对象，当它在后续迭代中被append方法修改时，所有指向它的引用（包括字典中已存储的那些引用）都会反映出这些修改。
立即学习“Python免费学习笔记（深入）”；
对比：不可变对象为何没有此问题？
为了更好地理解，我们对比一个使用不可变对象（如整数）的例子：
dict_int_values = {}
for i in range(3):
dict_int_values.update({i: i}) # 存储的是整数 i 的值
print(f"迭代 {i}: dict_int_values = {dict_int_values}")
print("\n最终结果:")
print(dict_int_values)输出如下：
迭代 0: dict_int_values = {0: 0}
迭代 1: dict_int_values = {0: 0, 1: 1}
迭代 2: dict_int_values = {0: 0, 1: 1, 2: 2}
最终结果:
{0: 0, 1: 1, 2: 2}这个结果符合预期。原因在于整数是不可变对象。每次循环中的i虽然值不同，但它们代表的是不同的整数对象。当dict_int_values.update({i: i})执行时，字典存储的是当前i所代表的整数对象的引用，由于整数不可变，后续循环中i的变化不会影响之前存储的整数值。
解决方案：存储列表的副本
要解决可变对象引用导致的问题，核心思想是在将列表添加到字典时，不是存储其引用，而是存储其独立副本。这样，即使原始列表在后续迭代中发生变化，字典中存储的副本也不会受到影响。
Python提供了多种创建列表浅副本的方法：
-
使用切片操作 [:]：这是创建列表副本的常用且简洁的方法。
my_list_copy = my_list[:]
-
使用 list() 构造函数：将现有列表作为参数传递给 list() 构造函数会创建一个新的列表。
my_list_copy = list(my_list)
-
使用 copy() 方法：列表对象自带的 copy() 方法是专门用于创建浅副本的。
my_list_copy = my_list.copy()
- *使用 `` 解包运算符 (Python 3.5+)**：结合列表字面量可以创建一个新列表。
my_list_copy = [*my_list]
推荐使用 my_list.copy()，因为它意图明确且易于理解。
以下是使用 copy() 方法修正后的代码：
dict_corrected = {}
current_list = [] # 保持变量名，但理解其作用
for i in range(3):
current_list.append(i)
# 关键：存储 current_list 的一个独立副本
dict_corrected.update({i: current_list.copy()})
print(f"迭代 {i}: current_list = {current_list}, dict_corrected = {dict_corrected}")
print("\n最终结果:")
print(dict_corrected)运行修正后的代码，输出将是：
迭代 0: current_list = [0], dict_corrected = {0: [0]}
迭代 1: current_list = [0, 1], dict_corrected = {0: [0, 1], 1: [0, 1]}
迭代 2: current_list = [0, 1, 2], dict_corrected = {0: [0, 1, 2], 1: [0, 1, 2], 2: [0, 1, 2]}
最终结果:
{0: [0], 1: [0, 1], 2: [0, 1, 2]}这正是我们期望的结果。字典中的每个键都关联了一个独立的列表副本，这些副本在创建时捕获了 current_list 的当前状态，并且不会受 current_list 后续变化的影响。
注意事项：浅拷贝与深拷贝
上述的 [:], list(), copy(), *[] 都是执行浅拷贝（Shallow Copy）。浅拷贝会创建一个新的容器对象（例如新的列表），但如果原始容器中包含其他可变对象（如列表中的列表），那么新容器中的这些内部对象仍然是原始对象的引用。
例如：
import copy
original_nested_list = [[1, 2], [3, 4]]
shallow_copy = original_nested_list.copy() # 浅拷贝
# 修改原始列表中的内部列表
original_nested_list[0].append(99)
print(f"原始列表: {original_nested_list}") # [[1, 2, 99], [3, 4]]
print(f"浅拷贝: {shallow_copy}") # [[1, 2, 99], [3, 4]] - 内部列表也变了如果你的列表值中包含嵌套的可变对象，并且你需要这些嵌套对象也是完全独立的副本，那么你需要使用深拷贝（Deep Copy）。深拷贝会递归地复制所有嵌套的可变对象，确保所有内容都是独立的。深拷贝通常通过 copy 模块中的 copy.deepcopy() 函数实现。
import copy
original_nested_list = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original_nested_list) # 深拷贝
# 修改原始列表中的内部列表
original_nested_list[0].append(99)
print(f"原始列表: {original_nested_list}") # [[1, 2, 99], [3, 4]]
print(f"深拷贝: {deep_copy}") # [[1, 2], [3, 4]] - 内部列表未受影响在本教程最初的问题场景中，列表 current_list 仅包含不可变的整数，因此浅拷贝已足够。但在处理更复杂的数据结构时，务必根据需求选择合适的拷贝方式。
总结
在Python中处理可变对象（如列表和字典）时，理解引用和副本的概念至关重要。当将可变对象作为值存储在数据结构中时，如果希望该值在原始对象被修改后保持不变，就必须存储其独立的副本。对于列表，通常使用 list.copy()、list[:] 或 list(list_obj) 来创建浅拷贝。对于包含嵌套可变对象的复杂结构，应考虑使用 copy.deepcopy() 进行深拷贝，以避免意外的数据污染。掌握这些技巧将帮助你编写更健壮、更可预测的Python代码。
