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,观察与解释：
-
最终矩阵内容： 所有的行都显示为[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的引用机制和赋值操作的语义，是编写健壮、可预测代码的关键。特别是在处理可变对象时，对这些细节的把握能有效避免常见的逻辑错误。
