Python中列表乘法与引用陷阱：深入理解可变对象行为-Python教程-PHP中文网

Python中列表乘法与引用陷阱：深入理解可变对象行为

碧海醫心

发布： 2025-10-03 13:47:21

原创

454人浏览过

Python中列表乘法与引用陷阱：深入理解可变对象行为

本文深入探讨了Python中使用乘法运算符*创建嵌套列表时常见的引用陷阱。通过具体代码示例，揭示了*操作符对可变对象（如列表）执行的是浅层复制，导致所有“副本”实际指向同一内存地址。文章详细解释了元素赋值操作如何进行引用重绑定，而非修改原有对象，最终导致所有共享引用的行显示相同内容。最后，提供了创建独立嵌套列表的正确方法，并强调了理解Python引用机制的重要性。

Python中列表乘法的行为：浅层复制与引用共享

在python中，当使用乘法运算符*来“复制”一个包含可变对象的列表时，例如创建嵌套列表，一个常见的误解是它会生成完全独立的副本。然而，*操作符实际上创建的是对原始对象的多个引用，而非独立的深层副本。这意味着所有“复制”出来的元素都指向内存中的同一个可变对象。

让我们通过一个示例来验证这一点。假设我们要创建一个3x2的矩阵，并用None填充。

# 假设 A 是一个用于确定维度的列表，例如 A = [[0,0],[0,0],[0,0]]
# 这里的 A 仅用于获取维度，实际内容不影响示例
rows = 3
cols = 2

empty_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 维度不变，假设仍为 3x2
rows = 3
cols = 2

for 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）所赋的值。

Booltool

常用AI图片图像处理工具箱

140

查看详情

例如，当 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 = 3
cols = 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 + j

print("\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() 函数来确保所有层级的对象都是独立的副本。