Python 列表是**有序、可变、可重复**的元素集合，底层基于「动态数组」实现（可自动扩容）。以下通过「可视化图解 + 代码」的方式，拆解列表的核心特性、结构和操作，直观理解列表的工作原理。
### 一、列表的核心特性（图解）


|特性|可视化说明|代码示例|
|:-:|:-:|:-:|
|有序性|元素按插入顺序排列，每个元素有唯一「索引」（从 0 开始） （示意：索引 0→1，索引 1→2，索引 2→3）|`lst = [1,2,3] print(lst[0]) # 1`|
|可变性|可直接修改、新增、删除元素（内存地址不变，仅内容变化） （修改索引 1 的值：2→9）|`lst[1] = 9 print(lst) # [1,9,3]`|
|元素类型不限|可包含任意数据类型（数字、字符串、列表、字典等） （索引 0：int，索引 1：str，索引 2：list）|`lst = [1, "a", [2,3]]`|
|可重复|允许元素重复，索引仍唯一 （索引 0 和 2 都是 1）|`lst = [1,2,1] print(lst) # [1,2,1]`|
### 二、列表的结构（内存视角图解）

列表在内存中是「连续的内存块 + 元素引用」的结构：
- 列表对象本身存储：**元素引用的指针数组 + 长度 + 容量**；
- 每个元素的指针指向实际数据的内存地址。

#### 可视化示意图（以 `lst = [1, "Python", [True]]` 为例）：

plaintext


```
列表对象（lst）
┌───────────┬───────────┬───────────┬───────────┐
│ 容量（8） │ 长度（3） │ 指针0 │ 指针1 │ 指针2 │
└───────────┴───────────┴───────────┴───────────┴───────────┘
 ↓ ↓ ↓
 ▼ ▼ ▼
实际数据内存 [1] ["Python"] [True]
内存地址 0x100 0x200 0x300
```

- 「容量」：列表预分配的内存空间（可存储的最大元素数，满了会自动扩容）；
- 「长度」：当前实际元素个数（`len(lst)` 获取）；
- 「指针」：指向每个元素的实际内存地址（因此列表可存不同类型元素）。

### 三、列表核心操作（图解 + 代码）

#### 1. 索引与切片（最常用操作）

##### （1）索引（访问单个元素）

索引分为「正索引」（从 0 开始）和「负索引」（从 -1 开始，倒数第一个）：
plaintext


```
列表： [10, 20, 30, 40, 50]
正索引： 0 1 2 3 4
负索引：-5 -4 -3 -2 -1
```

代码示例：
python

运行


```
lst = [10, 20, 30, 40, 50]
print(lst[2]) # 正索引：30（取第3个元素）
print(lst[-2]) # 负索引：40（取倒数第2个元素）
```

##### （2）切片（访问连续元素）

语法：`lst[起始索引:结束索引:步长]`（左闭右开，步长默认 1）
plaintext


```
列表： [10, 20, 30, 40, 50]
切片1：lst[1:4] → 取索引1到3 → [20,30,40]
切片2：lst[:3] → 从开头到索引2 → [10,20,30]
切片3：lst[2:] → 从索引2到结尾 → [30,40,50]
切片4：lst[::2] → 步长2 → [10,30,50]
切片5：lst[::-1]→ 步长-1（反转）→ [50,40,30,20,10]
```

代码示例：
python

运行


```
lst = [10, 20, 30, 40, 50]
print(lst[1:4]) # [20, 30, 40]
print(lst[::2]) # [10, 30, 50]
print(lst[::-1]) # [50, 40, 30, 20, 10]
```

#### 2. 新增元素（3 种方式）


|操作|图解说明|代码示例|
|:-:|:-:|:-:|
|`append()`|尾部新增元素（直接扩容，效率最高） `lst = [1,2] lst.append(3) print(lst) # [1,2,3]`|
|`insert()`|指定索引插入（后续元素后移，效率低） （索引 1 插入 9，原 1/2 后移）|`lst.insert(1,9) print(lst) # [1,9,2,3]`|
|`extend()`|尾部批量新增（合并另一个可迭代对象） |`lst.extend([4,5]) print(lst) # [1,9,2,3,4,5]`|
#### 3. 删除元素（4 种方式）


|操作|图解说明|代码示例|
|:-:|:-:|:-:|
|`remove()`|删除指定值的第一个元素（后续元素前移） （删除值为 9 的元素）|`lst.remove(9) print(lst) # [1,2,3,4,5]`|
|`pop()`|删除指定索引元素（默认最后一个），并返回该值 （删除索引 2 的 3）|`val = lst.pop(2) print(val) # 3 print(lst) # [1,2,4,5]`|
|`del`|删除指定索引 / 切片的元素（直接释放内存） （删除索引 1 的 2）|`del lst[1] print(lst) # [1,4,5]`|
|`clear()`|清空所有元素（列表对象保留，内容为空） |`lst.clear() print(lst) # []`|
#### 4. 列表遍历（2 种方式）

##### （1）遍历元素（直接遍历）

plaintext


```
列表：[10,20,30]
遍历过程：取10 → 取20 → 取30
```

代码：
python

运行


```
lst = [10,20,30]
for num in lst:
 print(num) # 依次输出10、20、30
```

##### （2）遍历索引 + 元素（`enumerate()`）

plaintext


```
列表：[10,20,30]
遍历过程：(0,10) → (1,20) → (2,30)
```

代码：
python

运行


```
lst = [10,20,30]
for idx, num in enumerate(lst):
 print(f"索引{idx}：{num}") # 索引0：10、索引1：20、索引2：30
```

### 四、列表高级操作（图解 + 代码）

#### 1. 列表推导式（快速生成列表）

语法：`[表达式 for 变量 in 可迭代对象 if 条件]`
##### 图解（生成 1-5 的平方列表）：

plaintext


```
可迭代对象：range(1,6) → 1、2、3、4、5
表达式：i*i → 1、4、9、16、25
结果列表：[1,4,9,16,25]
```

代码：
python

运行


```
square_lst = [i*i for i in range(1,6)]
print(square_lst) # [1, 4, 9, 16, 25]

# 带条件的推导式（筛选偶数）
even_lst = [i for i in range(1,10) if i%2 == 0]
print(even_lst) # [2,4,6,8]
```

#### 2. 嵌套列表（二维列表）

##### 图解（模拟矩阵）：

plaintext


```
嵌套列表：[[1,2,3], [4,5,6], [7,8,9]]
结构：
索引0 → [1,2,3]（行0）：索引0=1，索引1=2，索引2=3
索引1 → [4,5,6]（行1）：索引0=4，索引1=5，索引2=6
索引2 → [7,8,9]（行2）：索引0=7，索引1=8，索引2=9
```

代码：
python

运行


```
matrix = [[1,2,3], [4,5,6], [7,8,9]]
# 取第二行第三个元素（索引1,2）
print(matrix[1][2]) # 6
# 遍历嵌套列表
for row in matrix:
 for num in row:
 print(num, end=" ") # 1 2 3 4 5 6 7 8 9
```

#### 3. 列表排序（`sort()` vs `sorted()`）


|操作|图解说明|代码示例|
|:-:|:-:|:-:|
|`lst.sort()`|原地排序（修改原列表，无返回值） （[3,1,2]→[1,2,3]）|`lst = [3,1,2] lst.sort() print(lst) # [1,2,3]`|
|`sorted(lst)`|新列表排序（原列表不变，返回新列表） `lst = [3,1,2] new_lst = sorted(lst) print(lst) # [3,1,2] print(new_lst) # [1,2,3]`|
### 五、列表常见坑（图解提醒）

1. **浅拷贝问题**：嵌套列表的 `copy()` 仅拷贝外层，内层共享内存：
	plaintext
	```
	原列表：lst = [1, [2,3]]
	浅拷贝：lst_copy = lst.copy()
	修改内层：lst_copy[1][0] = 9
	结果：lst → [1, [9,3]]（原列表内层也变了）
	```
	解决：用 `copy.deepcopy()` 深拷贝：
	python
	运行
	```
	import copy
	lst = [1, [2,3]]
	lst_deep = copy.deepcopy(lst)
	lst_deep[1][0] = 9
	print(lst) # [1, [2,3]]（原列表不变）
	print(lst_deep) # [1, [9,3]]
	```
2. **索引越界**：访问超出列表长度的索引会报错：
	plaintext
	```
	列表：[1,2,3]（最大索引2）
	错误操作：lst[3] → IndexError
	```
	解决：先判断索引范围，或用 `lst.get()`（但列表无 `get()`，可结合 `len()`）：
	python
	运行
	```
	lst = [1,2,3]
	idx = 3
	if idx < len(lst):
	 print(lst[idx])
	else:
	 print("索引越界") # 输出：索引越界
	```

### 六、列表核心总结（图解版）

plaintext


```
列表核心
┌─────────────┬─────────────────────────┐
│ 核心特性 │ 有序、可变、元素类型不限 │
├─────────────┼─────────────────────────┤
│ 核心操作 │ 索引/切片、增/删/改/查 │
├─────────────┼─────────────────────────┤
│ 高效操作 │ 尾部增删（append/pop） │
├─────────────┼─────────────────────────┤
│ 低效操作 │ 头部/中间插入（insert） │
├─────────────┼─────────────────────────┤
│ 高级用法 │ 推导式、嵌套列表、排序 │
└─────────────┴─────────────────────────┘
```

Python 列表是有序、可变、可重复的元素集合，底层基于「动态数组」实现（可自动扩容）。以下通过「可视化图解 + 代码」的方式，拆解列表的核心特性、结构和操作，直观理解列表的工作原理。

图解python | 列表

后端

编程语言

Python列表是有序可变集合，支持索引/切片操作，可存储任意数据类型。动态数组结构实现自动扩容，提供append/pop高效操作，支持列表推导式、嵌套列表等高级用法。注意浅拷贝和索引越界问题，掌握sort()与sorted()区别。

Python

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

图解python | 列表-腾讯云开发者社区-腾讯云

图解python | 列表

图解python | 列表

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐