本文深入探讨了Python中使用乘法运算符*创建嵌套列表时常见的引用陷阱。通过具体代码示例，揭示了*操作符对可变对象（如列表）执行的是浅层复制，导致所有“副本”实际指向同一内存地址。文章详细解释了元素赋值操作如何进行引用重绑定，而非修改原有对象，最终导致所有共享引用的行显示相同内容。最后，提供了创建独立嵌套列表的正确方法，并强调了理解Python引用机制的重要性。
Python中列表乘法的行为：浅层复制与引用共享
在python中，当使用乘法运算符*来“复制”一个包含可变对象的列表时，例如创建嵌套列表，一个常见的误解是它会生成完全独立的副本。然而，*操作符实际上创建的是对原始对象的多个引用，而非独立的深层副本。这意味着所有“复制”出来的元素都指向内存中的同一个可变对象。
让我们通过一个示例来验证这一点。假设我们要创建一个3×2的矩阵，并用None填充。
# 假设 A 是一个用于确定维度的列表，例如 A = [[0,0],[0,0],[0,0]]# 这里的 A 仅用于获取维度，实际内容不影响示例rows = 3cols = 2empty_row = [None] * cols # 创建一个包含两个None的列表empty_matrix = [empty_row] * rows # 将 empty_row 引用三次print("--- 初始状态下的对象ID ---")for i in range(len(empty_matrix)): print(f"行 {i} 的对象ID: {id(empty_matrix[i])}") for j in range(len(empty_matrix[0])): print(f" 元素 ({i},{j}) 的对象ID: {id(empty_matrix[i][j])}", end = ", ") print()
运行上述代码，你会发现所有行的对象ID都是相同的，这表明empty_matrix中的所有元素都引用了同一个empty_row列表对象。同时，empty_row中的所有None元素也指向同一个None对象（None是不可变单例）。
示例输出可能如下（ID值会因运行环境而异）：
--- 初始状态下的对象ID ---行 0 的对象ID: 2856577670848 元素 (0,0) 的对象ID: 140733388238040, 元素 (0,1) 的对象ID: 140733388238040, 行 1 的对象ID: 2856577670848 元素 (1,0) 的对象ID: 140733388238040, 元素 (1,1) 的对象ID: 140733388238040, 行 2 的对象ID: 2856577670848 元素 (2,0) 的对象ID: 140733388238040, 元素 (2,1) 的对象ID: 140733388238040,
这清晰地表明，empty_matrix[0]、empty_matrix[1]和empty_matrix[2]都指向了同一个列表对象。
立即学习“Python免费学习笔记（深入）”；
可变对象元素的赋值操作：引用重绑定
现在，我们尝试向这个“矩阵”的每个元素赋值。
# 继续上面的 empty_matrix# A 维度不变，假设仍为 3x2rows = 3cols = 2for i in range(rows): for j in range(cols): empty_matrix[i][j] = i * 10 + j # 对元素进行赋值print("n--- 赋值后的矩阵内容 ---")for r in empty_matrix: for c in r: print(c, end = ", ") print()print("n--- 赋值后各对象ID ---")for i in range(len(empty_matrix)): print(f"行 {i} 的对象ID: {id(empty_matrix[i])}") for j in range(len(empty_matrix[0])): print(f" 元素 ({i},{j}) 的对象ID: {id(empty_matrix[i][j])}", end = ", ") print()
你可能会预期输出是：
0, 1,10, 11,20, 21,
然而，实际输出却是：
--- 赋值后的矩阵内容 ---20, 21, 20, 21, 20, 21,
为什么会这样？这是因为 empty_matrix[i][j] = value 这样的赋值操作，实际上是让 empty_matrix[i] 这个列表中的第 j 个位置的引用指向了一个新的 value 对象，而不是修改了原先被引用的对象。
由于 empty_matrix 中的所有行（empty_matrix[0], empty_matrix[1], empty_matrix[2]）都指向了同一个列表对象，当我们在循环中执行 empty_matrix[i][j] = i * 10 + j 时，我们实际上是在反复修改同一个列表对象的元素。每次循环迭代都会更新这个共享列表的元素。因此，当所有赋值操作完成后，这个共享列表的元素将是最后一次迭代（即 i=2）所赋的值。
例如，当 i=0, j=0 时，empty_matrix[0][0] = 0 会将共享列表的第一个元素从 None 变为 0。当 i=1, j=0 时，empty_matrix[1][0] = 10 会将共享列表的第一个元素从 0 变为 10。当 i=2, j=0 时，empty_matrix[2][0] = 20 会将共享列表的第一个元素从 10 变为 20。同理，共享列表的第二个元素最终会变为 21。
所以，最终所有行都显示 [20, 21]。
再观察赋值后的对象ID：
--- 赋值后各对象ID ---行 0 的对象ID: 1782995372160 元素 (0,0) 的对象ID: 1782914902928, 元素 (0,1) 的对象ID: 1782914902960, 行 1 的对象ID: 1782995372160 元素 (1,0) 的对象ID: 1782914902928, 元素 (1,1) 的对象ID: 1782914902960, 行 2 的对象ID: 1782995372160 元素 (2,0) 的对象ID: 1782914902928, 元素 (2,1) 的对象ID: 1782914902960,
你会发现：
所有行的ID仍然是相同的，这再次证明它们指向同一个列表对象。行内的元素ID已经改变，不再是最初的 None 对象的ID，而是新的整数对象的ID。例如，empty_matrix[0][0]、empty_matrix[1][0]、empty_matrix[2][0] 都指向同一个整数对象 20。
正确创建独立嵌套列表的方法
要创建包含独立列表的嵌套列表（即真正的二维矩阵），每行都应该是一个独立的列表对象。最常见和推荐的方法是使用列表推导式：
rows = 3cols = 2# 方法一：使用列表推导式# 每次循环都会创建一个新的列表对象matrix_correct = [[None for _ in range(cols)] for _ in range(rows)]print("--- 正确创建的矩阵 (列表推导式) ---")for i in range(rows): print(f"行 {i} 的对象ID: {id(matrix_correct[i])}") for j in range(cols): print(f" 元素 ({i},{j}) 的对象ID: {id(matrix_correct[i][j])}", end = ", ") print()# 进行赋值操作for i in range(rows): for j in range(cols): matrix_correct[i][j] = i * 10 + jprint("n--- 赋值后的正确矩阵内容 ---")for r in matrix_correct: for c in r: print(c, end = ", ") print()print("n--- 赋值后正确矩阵的各对象ID ---")for i in range(rows): print(f"行 {i} 的对象ID: {id(matrix_correct[i])}") for j in range(cols): print(f" 元素 ({i},{j}) 的对象ID: {id(matrix_correct[i][j])}", end = ", ") print()
运行这段代码，你会看到每行的ID都是不同的，证明它们是独立的列表对象。赋值后，输出将符合预期：
--- 赋值后的正确矩阵内容 ---0, 1, 10, 11, 20, 21,
此时，matrix_correct[0][0]、matrix_correct[1][0]、matrix_correct[2][0] 将分别指向整数对象 0、10、20，它们是不同的对象。
另一种使用循环创建独立嵌套列表的方法：
# 方法二：使用循环matrix_loop = []for _ in range(rows): matrix_loop.append([None] * cols) # 每次循环都创建一个新的列表对象并添加到 matrix_loop
这种方法与列表推导式达到相同的效果，即每行都是一个独立的列表对象。
总结与注意事项
列表乘法 (*) 的行为*：当对包含可变对象（如列表、字典、自定义类实例）的列表使用 `` 运算符时，它执行的是浅层复制**。这意味着新列表中的所有元素都是对原始可变对象的引用，它们都指向内存中的同一个对象。赋值操作 (=) 的行为：在Python中，list[index] = new_value 这样的赋值操作会重绑定引用。它使 list[index] 指向 new_value 对象，而不是修改 list[index] 原来指向的对象的内容。可变与不可变对象：理解可变对象（列表、字典、集合）和不可变对象（数字、字符串、元组）之间的区别至关重要。对不可变对象的“修改”实际上是创建了一个新对象并重绑定引用。而对可变对象的某些操作（如 list.append(), list.sort(), dict.update()）是原地修改对象内容，这些修改会通过所有引用可见。但 list[index] = new_value 仍是重绑定。创建独立副本：对于嵌套列表，创建独立副本的最佳实践是使用列表推导式，如 [[item for item in row] for row in original_matrix] 或 [[initial_value for _ in range(cols)] for _ in range(rows)]。对于更复杂的嵌套结构，可能需要使用 copy 模块中的 copy.deepcopy() 函数来确保所有层级的对象都是独立的副本。
通过深入理解Python的引用机制和赋值操作的本质，可以有效避免在处理复杂数据结构时遇到的常见陷阱，编写出更健壮、可预测的代码。
以上就是Python中列表乘法与引用陷阱：深入理解可变对象行为的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1375373.html
微信扫一扫 
支付宝扫一扫 
