30天精通Python语法 | Day9:吃透Python列表,批量数据存储的核心容器,新手必学

大家好，欢迎来到30天Python精通计划的第九天。

Day8我们一起搞定了for循环，学会了用更简洁的方式实现重复操作，很多同学都在评论区完成了打卡，甚至用for循环写出了九九乘法表，进步非常快！

但这段时间我也收到了很多新手同学的留言：

- 我要存储一个班级30个学生的成绩，难道要定义30个变量吗？太麻烦了

- 用for循环处理多个数据，总得先把数据存起来，有没有一个东西能一次性装下所有数据？

- 之前学的字符串只能存文本，能不能有个容器，既能存数字、又能存文本，还能随时修改？

别慌，这些问题的答案，就是今天我们要学的Python列表（List）。

列表是Python中最常用、最核心的数据容器，没有之一。如果说之前学的变量是「单个收纳盒」，一个盒子只能装一个数据，那列表就是「多层收纳柜」，一个柜子能装下无数个数据，还能给每个数据编上号，随时增、删、改、查，完美解决批量数据存储的问题。

更重要的是，列表和我们昨天学的for循环是黄金搭档，几乎所有批量数据处理、办公自动化、爬虫、数据分析的场景，都离不开列表的配合，是新手入门必须吃透的核心知识点。

学完今天的内容，你将：

✅ 彻底搞懂列表的本质，学会列表的定义与基础语法

✅ 掌握列表索引与切片，精准提取列表中的单个/多个数据

✅ 吃透列表增、删、改、查四大核心操作，覆盖所有日常使用场景

✅ 学会用for循环遍历列表，实现批量数据处理

✅ 掌握列表排序、反转、统计等高频内置方法，提升数据处理效率

✅ 避开列表操作的新手高频坑，解决90%的列表相关报错

✅ 为后续办公自动化、数据分析打下最核心的批量数据处理基础

一、先搞懂：什么是列表？

用一句大白话讲，列表是Python中专门用来存储多个有序数据的可变容器。

我们拆解一下核心特点，新手一眼就能懂：

1. 容器属性：一个列表可以同时存储多个数据，数量没有上限，哪怕存一万个、十万个数据都可以；

2. 有序性：列表里的每个数据都有固定的编号（索引），和字符串的索引规则完全一致，通过编号就能精准定位到对应的数据；

3. 可变性：列表创建完成后，可以随时修改、添加、删除里面的数据，这是它和字符串最核心的区别（字符串是不可变的，不能直接修改里面的字符）；

4. 兼容性：列表里可以同时存储不同类型的数据，整数、浮点数、字符串、布尔值，甚至嵌套另一个列表都可以，兼容性极强。

二、列表的基础定义与语法

列表的定义语法超级简单，新手看一眼就会：

列表必须用英文方括号 [] 包裹，里面的每一个数据叫做「元素」，元素和元素之间用英文逗号分隔。

下面我们用几个示例，带你掌握列表的3种常见定义方式，代码可以直接复制到PyCharm里运行：

python

# 1. 定义空列表（最基础，后续可以动态添加数据）

empty_list = []

print(empty_list)

# 2. 定义存储同类型数据的列表（最常用，比如存储成绩、姓名）

# 存储5个学生的考试成绩

score_list = [85, 92, 78, 90, 88]

print(score_list)

# 3. 定义存储混合类型数据的列表

# 同时存储姓名、年龄、身高、是否是学生

user_info = ["张三", 20, 1.75, True]

print(user_info)

# 4. 定义嵌套列表（列表里再放列表，比如存储多个学生的信息）

class_info = [

    ["张三", 20, 85],

    ["李四", 21, 92],

    ["王五", 19, 78]

]

print(class_info)

这里给新手一个核心提醒：列表里的元素，末尾可以多写一个逗号，Python不会报错，反而能避免后续添加元素时漏写逗号的问题，是行业里常用的小技巧。

三、列表的核心操作一：查（索引取值+切片）

我们把数据存进列表里，最基础的需求就是取出里面的数据，这就要用到和字符串完全一致的「索引取值」和「切片取值」，Day3学过的知识点可以直接复用，新手零门槛上手。

1. 索引取值：取出单个元素

列表的索引规则和字符串完全一致，新手可以直接联动记忆：

- 正向索引：从左到右，从0开始依次编号，第一个元素的索引是0，第二个是1，以此类推；

- 反向索引：从右到左，从-1开始依次编号，最后一个元素的索引是-1，倒数第二个是-2，以此类推。

语法格式： 列表名[索引编号] 

代码示例：

python

# 定义成绩列表

score_list = [85, 92, 78, 90, 88]

# 正向索引：取出第一个元素85

print(score_list[0])

# 正向索引：取出第三个元素78

print(score_list[2])

# 反向索引：取出最后一个元素88

print(score_list[-1])

# 反向索引：取出倒数第二个元素90

print(score_list[-2])

【新手避坑提示】索引编号绝对不能超出列表的长度范围，比如上面的列表只有5个元素，最大的正向索引是4，如果你写 score_list[5] ，程序会直接报「索引越界」错误，这是新手取列表元素时100%会踩的坑。

如果不确定列表的长度，可以用 len() 函数先查看， len(列表名) 会直接返回列表里的元素个数，比如 print(len(score_list)) ，会输出5。

2. 切片取值：取出多个元素

和字符串切片一样，列表切片可以一次性取出一段范围内的多个元素，生成一个新的列表，核心规则还是「左闭右开」，也就是包含起始索引对应的元素，不包含结束索引对应的元素。

完整语法格式： 列表名[起始索引:结束索引:步长] 

核心规则和Day3的字符串切片完全一致：

- 不写起始索引，默认从列表第一个元素开始；

- 不写结束索引，默认取到列表最后一个元素；

- 步长默认是1，也就是连续取元素，步长设为2就是隔一个取一个，步长设为-1就是倒序取元素。

代码示例：

python

# 定义成绩列表

score_list = [85, 92, 78, 90, 88, 95, 76]

# 取前3个元素

print(score_list[:3])

# 取索引2到索引5的元素（包含2，不包含5，也就是第3到第5个元素）

print(score_list[2:5])

# 从索引1开始，隔一个取一个

print(score_list[1::2])

# 倒序取出整个列表

print(score_list[::-1])

# 取从第二个元素到倒数第二个元素

print(score_list[1:-1])

【新手友好提示】列表切片哪怕结束索引超出了列表的最大长度，也不会报错，会自动取到列表的最后一个元素，比单个索引取值更安全。

四、列表的核心操作二：增（添加元素）

列表的核心优势就是可变，我们可以随时往列表里添加新的数据，Python给我们提供了3个高频添加元素的方法，覆盖了所有添加场景，下面我们逐个拆解清楚，讲清每个方法的用法、适用场景和区别。

1. append()：列表末尾添加单个元素

这是列表最常用的添加方法，核心作用是在列表的最末尾，添加一个新的元素，不管添加的是什么类型的数据，都会作为一个整体，变成列表的一个新元素。

语法格式： 列表名.append(要添加的元素) 

代码示例：

python

# 定义空的学生列表

student_list = ["张三", "李四", "王五"]

# 在列表末尾添加新学生"赵六"

student_list.append("赵六")

print(student_list)

# 在列表末尾添加一个数字

student_list.append(20)

print(student_list)

# 在列表末尾添加一个列表（会作为一个嵌套元素存在）

student_list.append([85, 90])

print(student_list)

2. extend()：列表末尾批量添加多个元素

这个方法专门用来解决「一次性添加多个元素」的需求，核心作用是把另一个可迭代对象（比如列表、字符串）里的所有元素，逐个拆出来，依次添加到列表的末尾。

语法格式： 列表名.extend(要添加的可迭代对象) 

这里必须给新手讲清append()和extend()的核心区别，这是新手100%会搞混的点：

- append()是把传入的内容，作为一个整体元素添加进去；

- extend()是把传入的内容，拆成一个个独立的元素，逐个添加进去。

代码示例对比：

python

# append()添加列表，会变成嵌套列表

list1 = [1, 2, 3]

list1.append([4, 5, 6])

print(list1)  # 输出结果：[1, 2, 3, [4, 5, 6]]，一共4个元素

# extend()添加列表，会逐个添加元素

list2 = [1, 2, 3]

list2.extend([4, 5, 6])

print(list2)  # 输出结果：[1, 2, 3, 4, 5, 6]，一共6个元素

3. insert()：在指定索引位置插入元素

append()和extend()只能在列表末尾添加元素，而insert()可以在列表的任意指定位置插入新元素，插入后，原位置及后面的所有元素，会自动向后移动一位。

语法格式： 列表名.insert(要插入的索引位置, 要插入的元素) 

代码示例：

python

student_list = ["张三", "李四", "王五"]

# 在索引1的位置（也就是张三和李四之间）插入"赵六"

student_list.insert(1, "赵六")

print(student_list)  # 输出：['张三', '赵六', '李四', '王五']

# 在列表开头插入元素

student_list.insert(0, "孙七")

print(student_list)

【新手提醒】insert()方法会改变列表里元素的索引，频繁使用会影响程序效率，除非必须在指定位置插入，否则优先用append()方法。

五、列表的核心操作三：改（修改元素）

修改列表里的元素超级简单，核心逻辑是：先通过索引定位到要修改的元素，然后直接用赋值运算符 = 给它赋新值即可，这也是列表「可变性」的核心体现。

语法格式： 列表名[要修改的元素索引] = 新的值 

代码示例：

python

score_list = [85, 92, 78, 90, 88]

# 修改索引2对应的元素，把78改成80

score_list[2] = 80

print(score_list)

# 修改最后一个元素，把88改成95

score_list[-1] = 95

print(score_list)

# 用切片批量修改多个元素

score_list[0:2] = [90, 95]

print(score_list)

【新手避坑提示】修改元素时，索引必须是已经存在的，不能用一个不存在的索引给列表赋值，比如列表只有5个元素，你写 score_list[5] = 100 ，会直接报索引越界错误，想要在末尾加元素，必须用append()方法。

六、列表的核心操作四：删（删除元素）

Python给列表提供了4种常用的删除方法，分别适用于不同的删除场景，下面我们逐个拆解，讲清每个方法的用法、区别和适用场景。

1. del：根据索引删除指定元素

del是Python的内置关键字，不是列表的专属方法，它的核心作用是根据索引，删除列表中指定位置的元素，也可以直接删除整个列表。

语法格式： del 列表名[要删除的元素索引] 

代码示例：

python

score_list = [85, 92, 78, 90, 88]

# 删除索引1对应的元素92

del score_list[1]

print(score_list)

# 删除最后一个元素

del score_list[-1]

print(score_list)

# 用切片批量删除多个元素

del score_list[0:2]

print(score_list)

# 直接删除整个列表，删除后列表就不存在了，再打印会报错

del score_list

2. pop()：根据索引删除元素，并返回被删除的值

pop()方法和del的核心区别是：pop()删除元素后，会把被删除的元素作为返回值，我们可以用变量接收这个值，后续继续使用；而del只是单纯删除元素，没有返回值。

pop()默认不写索引的话，会删除列表的最后一个元素，这也是它最常用的用法。

语法格式： 列表名.pop(要删除的元素索引) ，索引是可选的，默认删除最后一个元素。

代码示例：

python

student_list = ["张三", "李四", "王五", "赵六"]

# 默认删除最后一个元素，并用变量接收

deleted_student = student_list.pop()

print(f"被删除的学生是：{deleted_student}")

print(student_list)

# 删除索引1对应的元素李四

deleted_student2 = student_list.pop(1)

print(f"被删除的学生是：{deleted_student2}")

print(student_list)

3. remove()：根据元素值删除元素

del和pop()都是根据索引删除，而remove()是直接根据元素的值来删除，核心作用是删除列表中第一个匹配到的指定值。

语法格式： 列表名.remove(要删除的元素值) 

这里给新手两个必看的避坑提示：

1. 如果列表里有多个相同的元素，remove()只会删除从左到右第一个匹配到的元素，不会删除所有；

2. 如果要删除的元素值在列表里不存在，程序会直接报错，这是新手用remove()时最容易踩的坑。

代码示例：

python

score_list = [85, 92, 78, 90, 88, 78]

# 删除第一个出现的78

score_list.remove(78)

print(score_list)  # 输出：[85, 92, 90, 88, 78]，只删除了第一个78

# 错误示例：删除不存在的元素100，会直接报错

# score_list.remove(100)

4. clear()：清空列表所有元素

clear()方法的作用非常简单，就是一次性清空列表里的所有元素，让列表变成一个空列表，列表本身还存在，不会被删除。

语法格式： 列表名.clear() 

代码示例：

python

score_list = [85, 92, 78, 90, 88]

# 清空列表所有元素

score_list.clear()

print(score_list)  # 输出：[]，空列表

七、列表的黄金搭档：for循环遍历列表

我们把数据存进列表，最终目的是批量处理数据，这就离不开for循环的配合。列表是可迭代对象，用for循环可以轻松遍历列表里的每一个元素，实现批量处理，这也是列表最常用的场景。

下面给大家讲两种最常用的列表遍历方式，覆盖所有日常使用场景：

1. 直接遍历元素（最简单、最常用）

如果只需要获取列表里的每个元素，不需要知道元素对应的索引，直接用这种方式，代码最简洁。

语法格式：

python

for 临时变量 in 列表名:

    循环体代码，处理每个元素

代码示例：遍历成绩列表，统计及格人数

python

score_list = [85, 59, 78, 90, 45, 88, 92]

# 定义变量，统计及格人数

pass_count = 0

# 遍历列表里的每一个成绩

for score in score_list:

    # 判断成绩是否及格

    if score >= 60:

        pass_count += 1

        print(f"成绩{score}：及格")

    else:

        print(f"成绩{score}：不及格")

print(f"\n本次考试一共有{pass_count}人及格")

2. 带索引遍历：enumerate()函数

如果遍历的时候，不仅需要获取元素的值，还需要知道元素对应的索引，就用Python内置的enumerate()函数，它可以同时返回元素的索引和值。

语法格式：

python

for 索引变量, 元素变量 in enumerate(列表名):

    循环体代码

代码示例：遍历学生列表，打印每个学生的序号和姓名

python

student_list = ["张三", "李四", "王五", "赵六"]

# 遍历列表，同时获取索引和姓名

for index, name in enumerate(student_list):

    # 索引从0开始，序号从1开始，所以index+1

    print(f"第{index+1}位学生：{name}")

八、列表高频内置方法，新手必学

除了上面的增删改查，Python还给列表提供了很多实用的内置方法，下面我们整理了新手日常90%场景都会用到的5个方法，每个都讲清用法和代码示例。

1. sort()：列表排序

sort()方法的核心作用，是对列表里的元素进行原地排序，默认是升序（从小到大），可以通过参数修改为降序（从大到小）。

语法格式： 列表名.sort(reverse=False) ，reverse默认是False（升序），改成True就是降序。

代码示例：

python

score_list = [85, 92, 78, 90, 88]

# 默认升序排序，从小到大

score_list.sort()

print(score_list)

# 降序排序，从大到小

score_list.sort(reverse=True)

print(score_list)

2. reverse()：列表反转

reverse()方法的核心作用，是把列表里的元素顺序原地反转，首尾颠倒。

语法格式： 列表名.reverse() 

代码示例：

python

score_list = [85, 92, 78, 90, 88]

# 反转列表

score_list.reverse()

print(score_list)

3. count()：统计元素出现的次数

count()方法的核心作用，是统计列表中指定元素出现的次数，返回一个整数。

语法格式： 列表名.count(要统计的元素) 

代码示例：

python

score_list = [85, 92, 78, 90, 88, 78, 92, 78]

# 统计78出现的次数

count_78 = score_list.count(78)

print(f"78分出现的次数是：{count_78}")

4. index()：查找元素的索引

index()方法的核心作用，是查找列表中指定元素第一次出现的索引位置，如果元素不存在，会直接报错。

语法格式： 列表名.index(要查找的元素) 

代码示例：

python

student_list = ["张三", "李四", "王五", "赵六"]

# 查找"王五"的索引

index_wangwu = student_list.index("王五")

print(f"王五的索引位置是：{index_wangwu}")

九、新手高频踩坑避坑指南

这里整理了Day9学列表时，新手100%会遇到的报错和逻辑问题，提前讲清原因和解决方法，帮你少走弯路。

1. 索引越界报错：IndexError: list index out of range

这个报错是新手最常见的，核心原因是你取值、修改元素时，用的索引超出了列表的最大范围。解决方法：先用len()函数查看列表的长度，确保索引不超过「长度-1」，或者优先用反向索引，反向索引不容易出现越界问题。

2. append()和extend()搞混，列表变成嵌套结构

很多新手想批量添加多个元素，结果用了append()，导致列表里嵌套了另一个列表，后续遍历处理数据时出错。解决方法：添加单个元素用append()，批量添加多个元素用extend()，记住一个加整体、一个拆分开的核心区别。

3. 用remove()删除不存在的元素，触发报错

用remove()删除元素前，没有先判断元素是否在列表里，导致元素不存在时程序直接崩溃。解决方法：删除前先用 if 元素 in 列表名 判断元素是否存在，再执行删除操作。

4. 列表赋值的坑：修改新列表，原列表也跟着变

很多新手会写 list1 = [1,2,3]，list2 = list1 ，然后修改list2，结果发现list1也跟着变了。原因是这种赋值方式，只是给同一个列表起了两个名字，它们指向的是内存里的同一个列表。解决方法：用列表的copy()方法复制，比如 list2 = list1.copy() ，这样两个列表就是完全独立的，修改一个不会影响另一个。

5. 遍历列表的同时修改列表，导致元素遗漏

很多新手会在for循环遍历列表的时候，删除列表里的元素，结果导致后面的元素被跳过，遍历结果不符合预期。解决方法：遍历列表的副本，或者倒序遍历列表，避免因为元素索引变化导致的遗漏问题。

6. 列表里的元素类型不一致，批量处理时报错

比如列表里同时存了数字和字符串，遍历的时候统一做数学运算，会直接触发类型报错。解决方法：批量处理前，先判断元素的类型，或者确保列表里的元素类型统一。

十、今日课后作业（必做！只看不敲，永远学不会）

编程是一门实操技能，只有动手敲代码，才能真正把列表的知识点吃透。今天的作业循序渐进，覆盖列表所有核心操作，全部完成才算真正掌握。

1. 基础必做：定义一个列表，存储10个学生的考试成绩（自己随便写数字），完成以下操作：打印列表的第3个元素、打印列表的前5个元素、在列表末尾添加一个新成绩、修改列表里的最后一个成绩、删除列表里的第一个成绩，每一步操作后都打印列表，查看结果。

2. 进阶练习：用for循环遍历上面的成绩列表，计算所有成绩的平均分，统计出高于平均分的成绩个数，把结果打印出来。

3. 挑战练习：定义一个包含10个随机整数的列表，完成以下操作：对列表进行升序排序、去除列表里的重复元素、统计列表里最大数和最小数出现的次数，把每一步的结果都打印出来。

4. 习惯养成：给每一步操作都加上清晰的单行注释，变量名用规范的蛇形命名法，做到见名知意。

十一、明日预告

Day10我们将学习Python另外两个核心数据容器：元组（Tuple）和字典（Dict）。

我们会搞懂元组和列表的核心区别，学会用元组存储不可修改的固定数据；同时吃透字典的键值对结构，学会用更直观的方式存储和查询结构化数据，比如用户信息、商品详情等，彻底搞定Python三大核心数据容器。

结尾互动

今天的列表核心操作，你都学会了吗？

是不是终于解决了批量数据存储的痛点，不用再定义一堆变量了？

完成作业的同学，可以在评论区扣个【打卡Day9】！

遇到任何报错、知识点搞不懂的问题，都可以在评论区留言，我会一一解答。

关注我，跟着30天计划，从零开始，彻底精通Python核心语法，每天1.5小时，30天就能独立写Python脚本，搞定日常办公自动化！