Python二维列表完全指南：创建、遍历、矩阵运算及深拷贝陷阱

脚本专家

在Python开发中，一维列表能解决的问题有限，而二维列表（嵌套列表）才是处理表格、棋盘、图像等结构化数据的核心工具。本文将从创建、访问、修改、矩阵运算到深拷贝陷阱，系统梳理二维列表的实战技巧，并提供可直接运行的代码示例。

一、创建二维列表的正确姿势

1. 字面量创建（适用于小型固定数据）

2. matrix = [
3.     [1, 2, 3],
4.     [4, 5, 6],
5.     [7, 8, 9]
6. ]
7. print(matrix[0])      # [1, 2, 3]
8. print(matrix[1][2])   # 6
9. print(len(matrix))    # 3
10. print(len(matrix[0])) # 3

复制代码

2. 推导式创建（推荐）
推导式能生成规则矩阵，且每个内层列表都是独立对象。

2. # 3行4列全零矩阵
3. zeros = [[0 for _ in range(4)] for _ in range(3)]
4. print(zeros)
6. # 乘法表
7. table = [[i * j for j in range(1, 6)] for i in range(1, 6)]
8. for row in table:
9.     print(row)

复制代码

3. 经典陷阱：乘法创建

2. wrong = [[0] * 4] * 3
3. wrong[0][0] = 999
4. print(wrong)  # [[999, 0, 0, 0], [999, 0, 0, 0], [999, 0, 0, 0]]
5. # 三行都变了！因为 *3 复制的是同一内层列表的引用
6. print(wrong[0] is wrong[1])  # True
8. # 正确做法
9. correct = [[0] * 4 for _ in range(3)]
10. correct[0][0] = 999
11. print(correct)  # [[999, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
12. # 只有第一行变化

复制代码

乘法创建造成的“引用共享”是Python新手最易踩的坑，务必备注使用推导式。

4. 不规则（锯齿）二维列表

2. jagged = [
3.     [1, 2, 3],
4.     [4, 5],
5.     [6, 7, 8, 9]
6. ]
7. for i, row in enumerate(jagged):
8.     print(f'第{i}行有{len(row)}列')

复制代码

二、访问与遍历

1. 索引操作

2. matrix = [
3.     [1, 2, 3, 4],
4.     [5, 6, 7, 8],
5.     [9, 10, 11, 12]
6. ]
7. print(matrix[0][0])   # 1
8. print(matrix[1][2])   # 7
9. print(matrix[-1][-1]) # 12
10. print(matrix[0])      # 整行
11. col_0 = [row[0] for row in matrix]  # 整列
12. print(col_0)          # [1, 5, 9]

复制代码

2. 遍历推荐（enumerate双重循环）

2. for i, row in enumerate(matrix):
3.     for j, value in enumerate(row):
4.         print(f'matrix[{i}][{j}] = {value}')

复制代码

3. 行列切片与子矩阵

2. print(matrix[1][:2])  # [5, 6]
4. def submatrix(mat, rs, re, cs, ce):
5.     return [row[cs:ce] for row in mat[rs:re]]

复制代码

三、修改二维列表

1. 修改单个元素或整行

2. matrix[1][2] = 99
3. matrix[0] = [10, 20, 30]
4. # 修改整列需循环
5. for row in matrix:
6.     row[1] = 0

复制代码

2. 增删行列

2. matrix.append([7, 8, 9])          # 加一行
3. for i, row in enumerate(matrix):  # 加一列
4.     row.append((i + 1) * 10)
5. del matrix[1]                     # 删一行
6. for row in matrix:                # 删一列
7.     del row[-1]
8. matrix.insert(1, [100, 200, 300]) # 插入一行

复制代码

四、矩阵运算实战

1. 转置

2. def transpose(mat):
3.     if not mat:
4.         return []
5.     rows, cols = len(mat), len(mat[0])
6.     return [[mat[i][j] for i in range(rows)] for j in range(cols)]
8. # 或用 zip 简洁实现
9. transposed = [list(col) for col in zip(*matrix)]

复制代码

2. 加法与数乘

2. def matrix_add(a, b):
3.     rows, cols = len(a), len(a[0])
4.     return [[a[i][j] + b[i][j] for j in range(cols)] for i in range(rows)]
6. def matrix_scalar_mul(mat, scalar):
7.     return [[cell * scalar for cell in row] for row in mat]

复制代码

3. 矩阵乘法

2. def matrix_multiply(a, b):
3.     if not a or not b:
4.         return []
5.     if len(a[0]) != len(b):
6.         raise ValueError('矩阵尺寸不匹配')
7.     rows_a, cols_a = len(a), len(a[0])
8.     cols_b = len(b[0])
9.     result = [[0] * cols_b for _ in range(rows_a)]
10.     for i in range(rows_a):
11.         for j in range(cols_b):
12.             result[i][j] = sum(a[i][k] * b[k][j] for k in range(cols_a))
13.     return result
15. # 验证：2×3 乘 3×2 得 2×2
16. a = [[1, 2, 3], [4, 5, 6]]
17. b = [[7, 8], [9, 10], [11, 12]]
18. c = matrix_multiply(a, b)
19. print(c)  # [[58, 64], [139, 154]]

复制代码

五、棋盘游戏经典应用

1. 井字棋（Tic-Tac-Toe）
二维列表天然适合表示3×3棋盘，以下简化版状态机可实现胜负判断与落子。

2. class TicTacToe:
3.     def __init__(self):
4.         self.board = [[' ' for _ in range(3)] for _ in range(3)]
5.         self.current_player = 'X'
7.     def display(self):
8.         print('  0 1 2')
9.         for i, row in enumerate(self.board):
10.             print(f'{i} ' + ' | '.join(row))
11.             if i < 2:
12.                 print(' ---+---+---')
14.     def make_move(self, row, col):
15.         if self.board[row][col] != ' ':
16.             return False
17.         self.board[row][col] = self.current_player
18.         self.current_player = 'O' if self.current_player == 'X' else 'X'
19.         return True
21.     def check_winner(self):
22.         b = self.board
23.         # 检查行、列、对角线
24.         for row in b:
25.             if row[0] == row[1] == row[2] != ' ':
26.                 return row[0]
27.         for col in range(3):
28.             if b[0][col] == b[1][col] == b[2][col] != ' ':
29.                 return b[0][col]
30.         if b[0][0] == b[1][1] == b[2][2] != ' ':
31.             return b[0][0]
32.         if b[0][2] == b[1][1] == b[2][0] != ' ':
33.             return b[0][2]
34.         if all(cell != ' ' for row in b for cell in row):
35.             return '平局'
36.         return None

复制代码

2. 扫雷棋盘生成
随机布雷后，用方向数组计算周围雷数。

2. import random
4. def create_minesweeper(rows, cols, mines):
5.     board = [[0 for _ in range(cols)] for _ in range(rows)]
6.     mine_positions = set()
7.     while len(mine_positions) < mines:
8.         r = random.randint(0, rows - 1)
9.         c = random.randint(0, cols - 1)
10.         mine_positions.add((r, c))
11.         board[r][c] = -1
12.     directions = [(-1,-1), (-1,0), (-1,1), (0,-1),
13.                   (0,1), (1,-1), (1,0), (1,1)]
14.     for r, c in mine_positions:
15.         for dr, dc in directions:
16.             nr, nc = r + dr, c + dc
17.             if 0 <= nr < rows and 0 <= nc < cols and board[nr][nc] != -1:
18.                 board[nr][nc] += 1
19.     return board
21. board = create_minesweeper(8, 8, 10)
22. for row in board:
23.     print(' '.join(f'{cell:2d}' for cell in row))

复制代码

六、数据表格处理

1. CSV解析与排序

2. def parse_csv(text, delimiter=','):
3.     lines = text.strip().split('\n')
4.     return [line.split(delimiter) for line in lines if line.strip()]
6. csv_text = '''姓名,年龄,城市,职业
7. 小明,25,北京,工程师
8. 小红,23,上海,设计师
9. 小刚,26,广州,分析师'''
10. data = parse_csv(csv_text)
12. def sort_by_column(data, col_index, numeric=False):
13.     headers = data[0]
14.     body = data[1:]
15.     key_fn = lambda row: float(row[col_index]) if numeric else row[col_index]
16.     body.sort(key=key_fn)
17.     return [headers] + body
19. sorted_data = sort_by_column(data, 1, numeric=True)
20. for row in sorted_data:
21.     print(row)

复制代码

2. 数据透视表模拟

2. def pivot_table(data, row_field, col_field, value_field, agg_func=sum):
3.     row_values = sorted(set(d[row_field] for d in data))
4.     col_values = sorted(set(d[col_field] for d in data))
5.     pivot = [[0 for _ in range(len(col_values))] for _ in range(len(row_values))]
6.     row_idx = {v: i for i, v in enumerate(row_values)}
7.     col_idx = {v: i for i, v in enumerate(col_values)}
8.     groups = {}
9.     for record in data:
10.         key = (record[row_field], record[col_field])
11.         groups.setdefault(key, []).append(record[value_field])
12.     for (r, c), values in groups.items():
13.         pivot[row_idx[r]][col_idx[c]] = agg_func(values)
14.     return pivot, row_values, col_values

复制代码

七、三维列表与更深的嵌套

三维列表由多个二维平面堆叠而成，创建时仍需防范引用共享。

2. depth, rows, cols = 2, 3, 4
3. cube = [[[0 for _ in range(cols)] for _ in range(rows)] for _ in range(depth)]
4. cube[0][1][2] = 99
5. print(cube[0][1][2])  # 99
6. for p, plane in enumerate(cube):
7.     print(f'平面 {p}:')
8.     for row in plane:
9.         print(row)

复制代码

八、深拷贝与浅拷贝陷阱

嵌套列表的复制必须注意：浅拷贝只复制外层，内层列表共享引用。

2. import copy
4. original = [[1, 2], [3, 4]]
5. shallow = original[:]       # 浅拷贝
6. shallow[0][0] = 999
7. print(original)  # [[999, 2], [3, 4]] 已被修改
9. deep = copy.deepcopy(original)
10. deep[0][0] = 888
11. print(original)  # [[999, 2], [3, 4]] 不受影响

复制代码

如果不希望引入copy模块，可手动深拷贝二维列表：

2. [row[:] for row in original]

复制代码

。

总结：创建二维列表永远使用推导式；遍历推荐enumerate双重循环；矩阵运算掌握转置、加法、乘法；数据表格可用列表模拟CSV和透视；深拷贝是避免意外修改的关键。掌握这些技巧，二维列表将成为你处理结构化数据的得力工具。

热心网友7

很棒的文章！从创建到矩阵运算都讲得很清晰，特别是那个乘法创建陷阱的示例，直接对比 `wrong` 和 `correct` 的效果，新手一看就能明白为什么不能用 `[[0]*4]*3`。 不过标题里提到了“深拷贝陷阱”，正文中主要讲了乘法造成的引用共享，如果能把 `copy.deepcopy` 和 `copy.copy` 对二维列表的影响也加进来，比如直接用 `.copy()` 复制外层列表后内层还是同一引用，那就更完整了。当然，现在的讲解已经很实用了，特别是 `submatrix` 函数和用 `zip` 实现转置的技巧，直接拿来就能用。感谢分享！