Python 学习笔记4 —— List（列表）数据结构全面总结

Python 学习笔记 —— List（列表）数据结构全面总结

关键词：Python、List、列表、可变对象、CRUD、切片、引用、踩坑总结
适合人群：Python 初学者 / 刚接触数据结构的学习者

---

一、List（列表）概述

在 Python 的四种内置数据结构中：

• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

List 是学习成本最低、使用频率最高、也是最重要的一种。

几乎所有初学者的第一道“真正意义上的数据结构题”，都从 List 开始。

---

1.1 List 介绍

1. 为什么需要 List？

在不使用 List 的情况下，如果我们要保存多个数据，只能这样写：

score1 = 90
score2 = 85
score3 = 88

问题马上出现：

• 如果是 30 个成绩呢？
• 如果要对“第 5 个成绩”进行操作呢？
• 如果要整体遍历、修改、统计呢？

👉 普通变量无法承载“一组相关数据”
这正是 List 存在的意义。

---

1.2 List 的本质（一句话版）

List 是一种：
可以按顺序存放多个数据、并且允许修改的容器。

---

1.3 List 的核心特性（必须牢记）

• ✅ 可以存放 多个数据
• ✅ 数据 有顺序
• ✅ 索引从 0 开始
• ✅ 允许重复
• ✅ 元素可以修改
• ✅ 元素类型 不受限制
• ✅ List 是 可变对象（mutable）

---

二、创建列表

2.1 基本创建方式

lst = [1, 2, 3]

2.2 支持任意类型

lst = [1, "hello", True, [10, 20]]

📌 列表中可以嵌套列表

---

三、访问列表中的元素

3.1 索引（index）的概念

lst = ["a", "b", "c"]

索引	0	1	2
元素	a	b	c

📌 索引从 0 开始，这是新手第一大坑

---

3.2 通过索引访问元素

print(lst[0])  # a
print(lst[2])  # c

---

🚨 常见错误：索引越界

lst = [1, 2, 3]
print(lst[3])  # IndexError

---

四、列表的 CRUD 操作

CRUD = 增（Create）删（Delete）改（Update）查（Read）

---

4.1 添加元素（Create）

4.1.1 append —— 末尾添加（最常用）

lst = [1, 2, 3]
lst.append(4)

结果：

[1, 2, 3, 4]

📌 append 不生成新列表，而是修改原列表

---

🚨 append 踩坑总结

lst.append([5, 6])

结果是：

[1, 2, 3, 4, [5, 6]]

append 看整体，给什么，加什么

---

4.1.2 insert —— 指定位置插入

lst.insert(1, 100)

结果：

[1, 100, 2, 3]

📌 insert 是 插入，不是替换

---

🚨 insert 常见误区

lst.insert(1, [30, 40])

结果是：

[10, [30, 40], 20]

❌ 很多人误以为会“替换 20”

---

4.2 删除元素（Delete）

4.2.1 pop —— 按“位置”删（还能拿走）

x = lst.pop()

• 默认删除 最后一个
• 返回被删除的元素

x = lst.pop(1)

• 删除索引 1 的元素

📌 pop = 删除 + 返回

---

🚨 pop 默认行为踩坑

lst.pop()

❌ 不是“不删”
✅ 是“删最后一个”

---

4.2.2 remove —— 按“值”删

lst.remove(20)

• 只删除 第一个匹配的值
• 不返回任何东西

---

🚨 remove 踩坑总结

• 值不存在 → 报错
• 多个相同值 → 只删第一个

---

4.3 修改元素（Update）

lst[1] = 999

📌 索引赋值 = 替换

---

🚨 核心误区：赋值 vs 修改

a = lst      # 只是指向同一个列表
a[0] = 100   # 修改的是列表本身

多个变量可以指向同一个 List

---

4.4 查询元素（Read）

lst[i]

---

五、列表的其它常见操作

5.1 列表截取（切片）

5.1.1 基本形式

lst[start:end]

📌 左闭右开

---

5.1.2 常见写法

lst[:3]    # 从头到索引 3
lst[2:]    # 从索引 2 到结尾
lst[:]     # 浅拷贝

---

🚨 重要规则

所有切片操作，都会生成新列表

---

5.2 列表合并

5.2.1 使用 +

c = a + b

• 生成新列表
• 不修改原列表

---

5.2.2 使用 extend

a.extend(b)

• 修改原列表
• 不生成新列表

---

🚨 append vs extend 易混点

方法	行为
append	加整体
extend	拆开加

---

5.3 其它常用方法

5.3.1 sort —— 排序（改原列表）

lst.sort()

• 默认从小到大
• 返回值是 None

🚨 超级高频坑

a = lst.sort()  # a 是 None

---

5.3.2 sorted —— 排序（新列表）

new_lst = sorted(lst)

---

5.3.3 reverse —— 反转顺序

lst.reverse()

• 改原列表
• 不排序

---

5.3.4 index —— 查位置

lst.index(x)

🚨 只返回第一个匹配位置

---

5.3.5 count —— 统计次数

lst.count(x)

---

5.3.6 max / min

max(lst)
min(lst)

• 只是查看
• 不修改列表

---

六、List 学习中的“高频踩坑总结”

🚨 踩坑 1：以为 append 会生成新列表

❌ 错
✅ append 修改原列表

---

🚨 踩坑 2：index 会返回多个位置

❌ 错
✅ 只返回第一个

---

🚨 踩坑 3：sort 有返回值

❌ 错
✅ 永远返回 None

---

🚨 踩坑 4：a = lst 是复制列表

❌ 错
✅ 是“引用绑定”

---

🚨 踩坑 5：insert 是替换

❌ 错
✅ 是插入

---

七、终极总结（必须记住）

List 是一个：
有序、可变、可批量操作的容器

一句话终极口诀：

切片生新表，方法改自身
index 找第一个，sort 返回 None

---

八、⭐List（列表）学习中的「核心口诀 & 底层规则总结」

这一部分内容，不是给第一次看的人用的，
而是给你 学完一整轮 List 之后，用来“定型思维”的。
👉 建议反复阅读 + 背口诀，而不是死记函数。

---

1、List 的本质口诀（理解级）

List 是一个：
有序、可重复、可变、存放引用的容器

拆开理解就是：

• 有序：每个元素都有固定索引（从 0 开始）
• 可重复：相同的值可以出现多次
• 可变：
  • 元素的值可以改
  • 元素的数量（长度）也可以改
• 存放引用：变量名指向的是“列表对象”，不是值拷贝

📌 这是理解后面一切行为的根基

---

2、赋值与修改的终极口诀（最重要之一）

这是整个 List 学习中最容易混、但一旦想通就“通杀”的地方。

🔑 核心口诀

= 只是“绑定名字”，
真正修改列表的是：索引操作和列表方法

---

对比理解：

a = lst

• ❌ 没有复制列表
• ✅ 只是让 a 指向 lst 指向的同一个列表

lst[0] = 100

• ✅ 修改的是列表对象本身
• ✅ 所有指向这个列表的变量都会“看到变化”

📌 牢记一句话：

a = lst 不改列表，
a[i] = x 才是真的改列表

---

3、索引与赋值的执行流程口诀

这是你在学习过程中真正想明白的一点。

🔑 执行顺序口诀

Python 永远：
先算右边，再改左边

例如：

lst[0] = lst[2]

真实执行流程是：

1. 先计算 lst[2] 的值
2. 再找到 lst[0] 这个“位置”
3. 用右边的值覆盖左边的位置

📌 不会发生“自动交换”

---

4、append / insert 的终极区分口诀（高频踩坑点）

🔑 append 口诀

append 看整体，
右边给什么，就加什么

lst.append([4, 5])

结果一定是：

[1, 2, 3, [4, 5]]

---

🔑 insert 口诀

insert 是插入，不是替换
永远记住：位置 + 一个值

lst.insert(1, x)

• 原有元素 不会消失
• 后面的元素整体后移

📌 insert 只接收两个参数，不能插多个

---

5、CRUD 操作总口诀（必背）

这是 List 操作的“总纲级总结”。

查：用索引
改：索引赋值
增：append / insert / extend
删：pop（位置） / remove（值）

---

6、pop / remove 的终极区分口诀（考试级）

这是新手最容易混的一组。

🔑 一句话区分

知道位置 → pop
知道值 → remove

---

pop 专属口诀

pop = 删除 + 拿走（有返回值）

x = lst.pop()

• 默认删除最后一个
• x 得到被删除的元素

---

remove 专属口诀

remove = 按值删，只删第一个（无返回值）

---

7、切片（slice）的铁律口诀（非常重要）

🔑 切片本质口诀

凡是切片，必生新列表

lst[:]
lst[1:3]
lst[::-1]

• 都会生成新列表
• 都不会修改原列表

📌 切片是 List 里最安全的“复制方式”

---

8、合并操作的定型口诀

这是从“能用”到“用得对”的关键。

+ 合并：生成新列表
extend 合并：修改原列表
append 合并：产生嵌套

---

9、排序与反转的终极口诀（高频坑）

🔑 sort vs sorted

sort 排序自己，返回 None
sorted 不改原表，返回新表

lst.sort()        # 改原列表
sorted(lst)       # 新列表

📌 a = lst.sort() 永远是 None

---

🔑 reverse vs 切片翻转

reverse 改自己
切片翻转出新列表

lst.reverse()     # 改原列表
lst[::-1]         # 新列表

---

10、index / count 的终极区分口诀

index 只找第一个位置
count 只统计出现次数

• index()：
  • 找不到直接报错
  • 永远只返回一个整数
• count()：
  • 不修改列表
  • 只返回数字

---

11、一句话“List 总控口诀”（建议背下来）

List 是可变容器
方法多半改自身
切片一定生新表
sort 永远返 None

---

九、结语

到此为止，List（列表）这一章的内容已经被全面涵盖、总结，
现在可以顺利从 List 学习过渡到 Tuple（元组），
也可以通过这些“核心口诀”继续深入探索其它数据结构。
关注我，将为你带来更多，更深入的笔记