深入理解Python列表乘法与引用行为-Python教程-PHP中文网

深入理解Python列表乘法与引用行为

本文深入探讨Python中使用列表乘法（*运算符）创建嵌套列表时常见的引用陷阱。通过id()函数追踪对象的内存地址，详细解释了当列表包含可变对象时，乘法操作如何创建对同一对象的多个引用，以及后续对这些元素进行赋值操作时，为何会导致出乎意料的结果，并提供了创建独立嵌套列表的正确方法。

1. Python列表乘法与引用的初始状态

在python中，使用乘法运算符（*）来“乘以”一个列表是一种快速创建重复元素列表的方法。然而，当列表中的元素是可变对象（如另一个列表）时，这种操作并非简单地复制元素，而是创建了对同一对象的多个引用。

考虑以下示例，我们尝试创建一个二维矩阵，并使用id()函数来观察其内部元素的内存地址：

# 假设A是一个用于确定维度的数据，例如 A = [[0,0],[0,0],[0,0]]
# 这里我们仅使用其维度信息
rows = 3
cols = 2

# 创建一个包含None的单行列表
empty_row = [None] * cols
# 使用该行列表创建矩阵
empty_matrix = [empty_row] * rows

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 ---
行 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,

登录后复制

从输出中可以清晰地看到：

所有行的id()值都是相同的（例如2856577670848），这意味着empty_matrix中的所有行都引用了同一个列表对象empty_row。
所有元素的id()值也都是相同的（例如140733388238040），这表明它们都引用了同一个None对象。

这验证了一个关键概念：当使用[item] * N创建列表时，如果item是一个可变对象，则新列表中的所有元素都将是对此item的引用，而不是独立的副本。

立即学习“Python免费学习笔记（深入）”；

2. 赋值操作与引用行为的改变

现在，我们尝试向这个矩阵的每个元素赋值。通常，我们期望每个元素都能独立地被赋予新值。

# 假设A是一个用于确定维度的数据，例如 A = [[0,0],[0,0],[0,0]]
# 这里我们仅使用其维度信息
rows = 3
cols = 2

# 创建一个包含None的单行列表
empty_row = [None] * cols
# 使用该行列表创建矩阵
empty_matrix = [empty_row] * rows

print("--- 赋值前矩阵内容 ---")
for r in empty_matrix:
    print([c for c in r])

# 对矩阵元素进行赋值
for i in range(rows):
    for j in range(cols):
        empty_matrix[i][j] = i * 10 + j

print("\n--- 赋值后矩阵内容 ---")
for r in empty_matrix:
    print([c for c in r])

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()

登录后复制

运行上述代码，你会观察到以下输出：

--- 赋值前矩阵内容 ---
[None, None]
[None, None]
[None, None]

--- 赋值后矩阵内容 ---
[20, 21]
[20, 21]
[20, 21]

--- 赋值后列表元素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,

登录后复制

观察与解释：

飞书多维表格

表格形态的AI工作流搭建工具，支持批量化的AI创作与分析任务，接入DeepSeek R1满血版

查看详情

最终矩阵内容： 所有的行都显示为[20, 21]。这与我们期望的 [[0,1], [10,11], [20,21]] 大相径庭。这是因为empty_matrix中的所有行都是对同一个empty_row列表对象的引用。当我们执行empty_matrix[i][j] = value时，实际上是在修改这个共享的empty_row列表。
- i=0, j=0: empty_row[0] 被设置为 0。
- i=0, j=1: empty_row[1] 被设置为 1。
- i=1, j=0: empty_row[0] 被设置为 10（覆盖了之前的0）。
- i=1, j=1: empty_row[1] 被设置为 11（覆盖了之前的1）。
- i=2, j=0: empty_row[0] 被设置为 20（覆盖了之前的10）。
- i=2, j=1: empty_row[1] 被设置为 21（覆盖了之前的11）。因此，empty_row最终的状态是[20, 21]，由于所有行都引用它，所以整个empty_matrix看起来都是[[20, 21], [20, 21], [20, 21]]。
赋值后的元素ID：
- empty_matrix[i] 的ID仍然是相同的，这再次确认了所有行仍然引用同一个列表对象。
- empty_matrix[i][0] 的ID是相同的，empty_matrix[i][1] 的ID也是相同的，但 empty_matrix[i][0] 的ID与 empty_matrix[i][1] 的ID不同。这表明在共享的empty_row列表中，索引0和索引1现在分别指向了两个不同的整数对象（20和21）。

核心原理： 在Python中，empty_matrix[i][j] = new_value是一个赋值操作。它意味着将empty_matrix[i]（即共享的empty_row列表）中索引j处的引用，从旧对象（如None，或之前的某个整数）更改为指向new_value这个新对象。这个操作修改了共享列表empty_row的内部元素引用，而不是创建新的列表或独立的对象。

3. 正确创建独立嵌套列表的方法

为了避免上述引用陷阱，创建独立的嵌套列表（如二维矩阵）的推荐方法是使用列表推导式，确保每个内层列表都是一个全新的对象：

rows = 3
cols = 2

# 方法一：使用嵌套列表推导式
# 外层循环创建新的行，内层循环创建新行的元素
independent_matrix_1 = [[None for _ in range(cols)] for _ in range(rows)]

print("--- 独立矩阵（方法一） ---")
for r in independent_matrix_1:
    print([c for c in r])

# 赋值测试
for i in range(rows):
    for j in range(cols):
        independent_matrix_1[i][j] = i * 10 + j

print("\n--- 赋值后独立矩阵（方法一） ---")
for r in independent_matrix_1:
    print([c for c in r])

print("\n--- 赋值后独立矩阵（方法一）的ID ---")
for i in range(len(independent_matrix_1)):
    print(f"行 {i} 的ID: {id(independent_matrix_1[i])}")
    for j in range(len(independent_matrix_1[0])):
        print(f"     元素 [{i}][{j}] 的ID: {id(independent_matrix_1[i][j])}", end = ", ")
    print()

print("\n" + "="*30 + "\n")

# 方法二：使用循环创建
independent_matrix_2 = []
for _ in range(rows):
    independent_matrix_2.append([None] * cols) # 每次append一个新创建的列表

print("--- 独立矩阵（方法二） ---")
for r in independent_matrix_2:
    print([c for c in r])

# 赋值测试
for i in range(rows):
    for j in range(cols):
        independent_matrix_2[i][j] = i * 10 + j

print("\n--- 赋值后独立矩阵（方法二） ---")
for r in independent_matrix_2:
    print([c for c in r])

print("\n--- 赋值后独立矩阵（方法二）的ID ---")
for i in range(len(independent_matrix_2)):
    print(f"行 {i} 的ID: {id(independent_matrix_2[i])}")
    for j in range(len(independent_matrix_2[0])):
        print(f"     元素 [{i}][{j}] 的ID: {id(independent_matrix_2[i][j])}", end = ", ")
    print()

登录后复制

运行上述代码，你将看到预期的输出：

--- 独立矩阵（方法一） ---
[None, None]
[None, None]
[None, None]

--- 赋值后独立矩阵（方法一） ---
[0, 1]
[10, 11]
[20, 21]

--- 赋值后独立矩阵（方法一）的ID ---
行 0 的ID: 1782995372320
     元素 [0][0] 的ID: 140733388238040,      元素 [0][1] 的ID: 140733388238072, 
行 1 的ID: 1782995372480
     元素 [1][0] 的ID: 140733388238400,      元素 [1][1] 的ID: 140733388238432, 
行 2 的ID: 1782995372640
     元素 [2][0] 的ID: 140733388238720,      元素 [2][1] 的ID: 140733388238752, 

==============================

--- 独立矩阵（方法二） ---
[None, None]
[None, None]
[None, None]

--- 赋值后独立矩阵（方法二） ---
[0, 1]
[10, 11]
[20, 21]

--- 赋值后独立矩阵（方法二）的ID ---
行 0 的ID: 1782995372160
     元素 [0][0] 的ID: 140733388238040,      元素 [0][1] 的ID: 140733388238072, 
行 1 的ID: 1782995372400
     元素 [1][0] 的ID: 140733388238400,      元素 [1][1] 的ID: 140733388238432, 
行 2 的ID: 1782995372640
     元素 [2][0] 的ID: 140733388238720,      元素 [2][1] 的ID: 140733388238752,

登录后复制

可以看到，两种正确方法创建的矩阵在赋值后都能保持独立性。其关键在于，每次生成内层列表时都创建了一个新的列表对象，而不是引用同一个列表对象。

4. 总结与注意事项

*列表乘法（`）的引用行为：** 当使用[item] * N创建列表时，如果item是一个可变对象（如列表、字典、集合等），则新列表中的所有元素都将是对该item的引用。这意味着修改其中一个元素会影响所有引用了该item`的元素。
赋值操作（=）的含义： variable = value或list[index] = value是将一个变量名或列表槽位绑定到value这个新对象上。它改变的是引用关系，而不是修改被引用的旧对象（除非value本身就是对旧对象的修改）。
创建独立嵌套列表： 对于需要独立修改的嵌套列表，应避免使用[[]] * N这种形式。推荐使用列表推导式 [[初始值 for _ in range(cols)] for _ in range(rows)] 或显式循环创建，以确保每个内层列表都是一个独立的新对象。
不可变对象的情况： 如果列表中的元素是不可变对象（如整数、浮点数、字符串、元组），那么使用*运算符通常是安全的，因为不可变对象一旦创建就不能被修改。即使它们被引用多次，对其中一个“元素”的“修改”实际上是创建了一个新对象并重新赋值，不会影响其他引用。

理解Python的引用机制和赋值操作的语义，是编写健壮、可预测代码的关键。特别是在处理可变对象时，对这些细节的把握能有效避免常见的逻辑错误。

以上就是深入理解Python列表乘法与引用行为的详细内容，更多请关注php中文网其它相关文章！