03.Python列表

前言

列表（List）是 Python 中最灵活、最常用的数据结构之一，作为有序可变序列，它能存储不同类型的数据，支持增删改查等丰富操作，是处理批量数据的核心工具。本文从基础概念到实战案例，全方位拆解列表的使用技巧，适合零基础入门者系统学习，也可作为进阶者的查漏补缺手册～

零、必背核心知识点

1. 列表的定义与核心特点

定义：Python 中最常用的有序可变序列，用于存储多个数据（可不同类型）。
核心特点：
- 有序性：元素有固定索引，支持按位置访问；
- 可变性：元素可增、删、改，不改变列表本身的标识；
- 包容性：可存储整数、字符串、布尔值、列表等任意类型数据。

2. 核心使用原则

一次性存储多个数据（优先存储同类型数据，便于后续处理）；
需频繁修改数据时优先使用（对比元组、字符串的不可变性）；
索引从 0 开始（正索引），也支持负索引（从 - 1 开始，反向计数）；
切片操作不改变原列表，返回新列表。

一、列表的创建方式

Python 中创建列表主要有 2 种常用方式，其中中括号创建法最简洁高效。

1. 中括号创建法（最常用）

直接用[]包裹元素，支持空列表、同类型元素、混合类型元素、嵌套列表等场景。

python

运行

# 1. 创建空列表 empty_list = [] print("空列表:", empty_list) # 输出：空列表: [] # 2. 创建包含同类型元素的列表 numbers_list = [1, 2, 3, 4, 5] print("数字列表:", numbers_list) # 输出：数字列表: [1, 2, 3, 4, 5] # 3. 创建包含不同类型元素的列表 mixed_list = [10, "hello", True, 3.14] print("混合类型列表:", mixed_list) # 输出：混合类型列表: [10, 'hello', True, 3.14] # 4. 创建嵌套列表（列表中包含列表） nested_list = [1, [2, 3], ["a", "b"]] print("嵌套列表:", nested_list) # 输出：嵌套列表: [1, [2, 3], ['a', 'b']] # 5. 元组转列表（利用list()函数） tuple_list = list((1, 2, 3)) print("元组转列表:", tuple_list) # 输出：元组转列表: [1, 2, 3]

2. list () 函数创建法

通过list()函数将可迭代对象（range、字符串、元组等）转换为列表。

python

运行

# 1. 从range对象创建列表 range_list = list(range(1, 11)) # range(1,11)生成1-10的整数 print("range转列表:", range_list) # 输出：range转列表: [1, 2, 3, ..., 10] # 2. 从字符串创建列表（每个字符作为独立元素） str_list = list("python") print("字符串转列表:", str_list) # 输出：字符串转列表: ['p', 'y', 't', 'h', 'o', 'n'] # 3. 从集合创建列表（注意：集合无序，列表会保留转换时的顺序） set_list = list({1, 3, 2}) print("集合转列表:", set_list) # 输出：集合转列表: [1, 2, 3]（顺序可能不同）

二、列表的基础操作（增删改查）

列表的基础操作围绕 “增、删、改、查” 展开，是日常开发中最常用的功能，每个操作都有明确的使用场景。

1. 查：获取列表元素

根据需求可分为 “获取单个元素”“遍历所有元素”“获取嵌套元素” 三种场景。

（1）获取单个元素（按索引访问）

语法：列表[索引]，支持正索引（从 0 开始）和负索引（从 - 1 开始）。

python

运行

fruits = ["苹果", "香蕉", "橙子", "葡萄"] # 正索引：0-3 print("索引1的元素:", fruits[1]) # 输出：索引1的元素: 香蕉 # 负索引：-1（最后一个）、-2（倒数第二个） print("倒数第一个元素:", fruits[-1]) # 输出：倒数第一个元素: 葡萄 print("倒数第二个元素:", fruits[-2]) # 输出：倒数第二个元素: 橙子

（2）遍历所有元素（for 循环）

通过for循环逐个获取列表元素，适合批量处理数据。

python

运行

numbers = [1, 2, 3, 4, 5] # 方式1：直接遍历元素 print("直接遍历元素:") for num in numbers: print(num, end=" ") # 输出：1 2 3 4 5 # 方式2：通过索引遍历（enumerate获取索引和元素） print("\n通过索引遍历:") for index, num in enumerate(numbers): print(f"索引{index}: {num}", end=" ") # 输出：索引0:1 索引1:2 ... 索引4:5

（3）获取嵌套列表的元素

语法：列表[外层索引][内层索引]...，逐层访问嵌套的列表。

python

运行

nested = [1, [2, 3, [4, 5]], 6] # 需求：访问最内层的5 # 步骤1：获取外层列表索引1的元素 → [2, 3, [4, 5]] # 步骤2：获取内层列表索引2的元素 → [4, 5] # 步骤3：获取最内层列表索引1的元素 → 5 print("嵌套列表的内层元素:", nested[1][2][1]) # 输出：嵌套列表的内层元素: 5

2. 增：向列表添加元素

根据添加场景不同，提供 3 种方法：append()（单个元素）、extend()（多个元素）、insert()（指定位置）。

（1）append ()：在列表末尾添加单个元素

语法：列表.append(元素)，仅能添加一个元素（可是任意类型）。

python

运行

list1 = [1, 2, 3] # 添加单个数字 list1.append(4) print("添加单个数字后:", list1) # 输出：添加单个数字后: [1, 2, 3, 4] # 添加单个字符串 list1.append("hello") print("添加单个字符串后:", list1) # 输出：添加单个字符串后: [1, 2, 3, 4, 'hello'] # 添加嵌套列表（作为单个元素） list1.append([5, 6]) print("添加嵌套列表后:", list1) # 输出：添加嵌套列表后: [1, 2, 3, 4, 'hello', [5, 6]]

（2）extend ()：在列表末尾添加多个元素（合并列表）

语法：列表.extend(可迭代对象)，接收列表、range、字符串等可迭代对象，将其元素逐个添加到原列表。

python

运行

list2 = [1, 2, 3] # 添加多个元素（通过列表） list2.extend([4, 5, 6]) print("添加列表元素后:", list2) # 输出：添加列表元素后: [1, 2, 3, 4, 5, 6] # 添加range对象的元素 list2.extend(range(7, 10)) # range(7,10) → 7,8,9 print("添加range元素后:", list2) # 输出：添加range元素后: [1, 2, 3, 4, 5, 6, 7, 8, 9] # 添加字符串的元素（每个字符） list2.extend("abc") print("添加字符串元素后:", list2) # 输出：添加字符串元素后: [1,2,...,9,'a','b','c']

（3）insert ()：在指定索引位置添加单个元素

语法：列表.insert(索引, 元素)，在索引前插入元素，原元素向后顺延。

python

运行

list3 = [1, 2, 3] # 在索引1的位置插入22（原索引1的元素2向后移动） list3.insert(1, 22) print("指定位置插入元素后:", list3) # 输出：指定位置插入元素后: [1, 22, 2, 3] # 在末尾插入元素（等价于append()） list3.insert(len(list3), 4) print("末尾插入元素后:", list3) # 输出：末尾插入元素后: [1, 22, 2, 3, 4]

3. 改：修改列表元素

直接通过 “索引赋值” 修改元素，语法：列表[索引] = 新值。

python

运行

list4 = [1, 2, 3, 4, 5] # 修改索引2的元素（原元素3改为33） list4[2] = 33 print("修改单个元素后:", list4) # 输出：修改单个元素后: [1, 2, 33, 4, 5] # 修改嵌套列表的元素 nested_list = [1, [2, 3], 4] nested_list[1][0] = 22 # 修改内层列表索引0的元素 print("修改嵌套列表元素后:", nested_list) # 输出：修改嵌套列表元素后: [1, [22, 3], 4]

4. 删：删除列表元素

提供 3 种删除方法，适用于不同场景：del（按位置）、remove()（按值）、pop()（按位置并返回）。

（1）del：按索引删除元素（无返回值）

语法：del 列表[索引]，直接删除指定索引的元素，不返回被删除的元素。

python

运行

list5 = [1, 2, 3, 4, 5, 6, 5] # 删除索引2的元素（值为3） del list5[2] print("按索引删除后:", list5) # 输出：按索引删除后: [1, 2, 4, 5, 6, 5] # 删除切片范围内的元素（删除索引1-3的元素） del list5[1:4] print("按切片删除后:", list5) # 输出：按切片删除后: [1, 6, 5]

（2）remove ()：按值删除元素（无返回值）

语法：列表.remove(值)，删除列表中第一个匹配该值的元素，无返回值；若值不存在，报错。

python

运行

test_list = [1, 2, "hello", 3, 4, "hello", 5, 6, "hello"] # 删除第一个值为"hello"的元素 test_list.remove("hello") print("按值删除后:", test_list) # 输出：按值删除后: [1, 2, 3, 4, 'hello', 5, 6, 'hello'] # 若删除不存在的值，会报错 # test_list.remove("world") # 报错：ValueError: list.remove(x): x not in list

（3）pop ()：按索引删除元素（返回被删除的元素）

语法：列表.pop(索引)，默认删除最后一个元素，返回被删除的元素；指定索引则删除对应元素。

python

运行

last_list = [1, 2, 3, 4, 5] # 默认删除最后一个元素 last_element = last_list.pop() print("被删除的元素:", last_element) # 输出：被删除的元素: 5 print("删除后列表:", last_list) # 输出：删除后列表: [1, 2, 3, 4] # 指定索引删除（删除索引1的元素） 指定_element = last_list.pop(1) print("指定索引删除的元素:", 指定_element) # 输出：指定索引删除的元素: 2 print("指定索引删除后列表:", last_list) # 输出：指定索引删除后列表: [1, 3, 4]

三、列表的进阶操作：切片

切片是列表的核心进阶功能，用于快速获取列表的子列表，语法简洁且灵活。

1. 切片语法

python

运行

列表[start_index:end_index:step]

start_index：起始索引（包含），默认 0（从开头开始）；
end_index：结束索引（不包含），默认列表长度（到末尾结束）；
step：步长（每次移动的位数），默认 1，负数表示反向切片。

2. 核心规则

正索引：从左往右计数（0、1、2...）；负索引：从右往左计数（-1、-2、-3...）；
end_index始终不包含对应元素（左闭右开区间）；
切片不改变原列表，返回新列表。

3. 常用切片示例

python

运行

# 基础列表：0-9的数字 numbers_list = list(range(0, 10)) # [0,1,2,3,4,5,6,7,8,9] print("原列表:", numbers_list) # 示例1：从索引2到5（不包含5），步长1 slice1 = numbers_list[2:5] print("切片[2:5]:", slice1) # 输出：切片[2:5]: [2, 3, 4] # 示例2：从开头到索引3（不包含3），步长1（省略start_index） slice2 = numbers_list[:3] print("切片[:3]:", slice2) # 输出：切片[:3]: [0, 1, 2] # 示例3：从索引3到末尾，步长1（省略end_index） slice3 = numbers_list[3:] print("切片[3:]:", slice3) # 输出：切片[3:]: [3,4,5,6,7,8,9] # 示例4：步长为2（每隔1个元素取1个） slice4 = numbers_list[::2] print("切片[::2]:", slice4) # 输出：切片[::2]: [0,2,4,6,8] # 示例5：反向切片（步长为-1，反转列表） slice5 = numbers_list[::-1] print("切片[::-1]:", slice5) # 输出：切片[::-1]: [9,8,7,6,5,4,3,2,1,0] # 示例6：指定start和end的反向切片（从索引9到4，不包含4） slice6 = numbers_list[9:4:-1] print("切片[9:4:-1]:", slice6) # 输出：切片[9:4:-1]: [9,8,7,6,5] # 示例7：负索引切片（从倒数第1个到倒数第4个，不包含倒数第4个） slice7 = numbers_list[-1:-4:-1] print("切片[-1:-4:-1]:", slice7) # 输出：切片[-1:-4:-1]: [9,8,7]

四、列表的其他常用操作

除了基础操作和切片，列表还支持拼接、重复、成员判断等实用功能。

1. 拼接（+）：合并两个列表

语法：列表1 + 列表2，返回新列表（包含两个列表的所有元素），原列表不变。

python

运行

list_a = [1, 2, 3] list_b = [4, 5, 6] # 拼接两个列表 new_list = list_a + list_b print("拼接后的列表:", new_list) # 输出：拼接后的列表: [1,2,3,4,5,6] print("原列表a:", list_a) # 输出：原列表a: [1,2,3]（不变） print("原列表b:", list_b) # 输出：原列表b: [4,5,6]（不变）

2. 重复（*）：重复列表元素

语法：列表 * n，返回新列表（原列表元素重复 n 次），原列表不变。

python

运行

test_list = [1, 2, 3] # 重复3次 repeat_list = test_list * 3 print("重复后的列表:", repeat_list) # 输出：重复后的列表: [1,2,3,1,2,3,1,2,3] print("原列表:", test_list) # 输出：原列表: [1,2,3]（不变）

3. 成员判断（in /not in）：判断元素是否在列表中

语法：元素 in 列表或元素 not in 列表，返回布尔值（True/False）。

python

运行

fruit_list = ["苹果", "香蕉", "橙子"] # 判断元素是否存在 print("香蕉在列表中:", "香蕉" in fruit_list) # 输出：香蕉在列表中: True print("葡萄在列表中:", "葡萄" in fruit_list) # 输出：葡萄在列表中: False # 判断元素是否不存在 print("葡萄不在列表中:", "葡萄" not in fruit_list) # 输出：葡萄不在列表中: True

五、列表推导式（高效创建列表）

列表推导式是 Python 的特色语法，能通过简洁的代码快速创建列表，比传统 for 循环更高效、更易读。

1. 基础格式（仅循环）

语法：新列表 = [表达式 for 变量 in 可迭代对象]

示例：将 1-5 的数字翻倍

python

运行

# 列表推导式 nums = [x * 2 for x in range(1, 6)] print("推导式创建的列表:", nums) # 输出：推导式创建的列表: [2,4,6,8,10] # 等价于传统for循环 nums_old = [] for x in range(1, 6): nums_old.append(x * 2) print("传统循环创建的列表:", nums_old) # 输出：传统循环创建的列表: [2,4,6,8,10]

2. 进阶格式（循环 + 条件筛选）

语法：新列表 = [表达式 for 变量 in 可迭代对象 if 条件判断]

示例：筛选 1-10 中的偶数

python

运行

# 列表推导式 even_nums = [x for x in range(1, 11) if x % 2 == 0] print("筛选后的偶数列表:", even_nums) # 输出：筛选后的偶数列表: [2,4,6,8,10] # 等价于传统for循环 even_nums_old = [] for x in range(1, 11): if x % 2 == 0: even_nums_old.append(x) print("传统循环筛选的偶数列表:", even_nums_old) # 输出：传统循环筛选的偶数列表: [2,4,6,8,10]

3. 嵌套格式（多循环 + 多条件）

语法：新列表 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2 if 条件1 and 条件2]

示例：生成 1-3 和 1-3 的乘积，且乘积 > 3 的组合

python

运行

# 列表推导式 products = [x * y for x in range(1, 4) for y in range(1, 4) if x * y > 3] print("满足条件的乘积列表:", products) # 输出：满足条件的乘积列表: [4,6,6,9] # 等价于传统嵌套for循环 products_old = [] for x in range(1, 4): for y in range(1, 4): if x * y > 3: products_old.append(x * y) print("传统嵌套循环的乘积列表:", products_old) # 输出：传统嵌套循环的乘积列表: [4,6,6,9]

六、列表常用内置函数

Python 提供了多个内置函数，用于快速处理列表，提高开发效率。

函数名	作用	示例	输出结果
`len(list)`	返回列表长度（元素个数）	`len([1, 2, 3])`	3
`max(list)`	返回列表中最大元素（元素需可比较）	`max([5, 2, 8])`	8
`min(list)`	返回列表中最小元素（元素需可比较）	`min([5, 2, 8])`	2
`sum(list)`	返回列表中所有元素的和（元素需为数字）	`sum([1, 2, 3])`	6
`sorted(list)`	返回排序后的新列表（原列表不变）	`sorted([3, 1, 2])`	[1, 2, 3]
`list.reverse()`	反转列表（原地修改，无返回值）	`numbers = [1,2,3]; numbers.reverse()`	原列表变为 [3,2,1]
`list.count(x)`	统计元素 x 在列表中出现的次数	`[1, 2, 2, 3].count(2)`	2
`list.index(x)`	返回元素 x 第一次出现的索引（不存在报错）	`[1, 2, 3].index(2)`	1

函数使用示例

python

运行

numbers = [3, 1, 4, 1, 5, 9, 2, 6] print("列表:", numbers) # 1. 列表长度 print("列表长度:", len(numbers)) # 输出：列表长度: 8 # 2. 最大/最小值 print("最大值:", max(numbers)) # 输出：最大值: 9 print("最小值:", min(numbers)) # 输出：最小值: 1 # 3. 元素总和 print("元素总和:", sum(numbers)) # 输出：元素总和: 31 # 4. 排序（返回新列表） sorted_nums = sorted(numbers) print("排序后的新列表:", sorted_nums) # 输出：排序后的新列表: [1,1,2,3,4,5,6,9] print("原列表（不变）:", numbers) # 输出：原列表（不变）: [3,1,4,1,5,9,2,6] # 5. 反转列表（原地修改） numbers.reverse() print("反转后的列表:", numbers) # 输出：反转后的列表: [6,2,9,5,1,4,1,3] # 6. 统计元素出现次数 print("元素1出现次数:", numbers.count(1)) # 输出：元素1出现次数: 2 # 7. 获取元素第一次出现的索引 print("元素5第一次出现的索引:", numbers.index(5)) # 输出：元素5第一次出现的索引: 3

七、实战案例：成绩统计系统

结合列表的各项操作，实现一个完整的成绩统计功能，涵盖添加、计算、筛选、排序等核心场景。

1. 题目要求

初始化空列表scores，存储学生成绩；
逐个添加成绩：85、92、78、45、59；
批量添加成绩：90、88；
输出完整成绩列表；
计算并输出最高分、最低分；
计算并输出平均分（保留 2 位小数）；
筛选并输出所有不及格（<60）的成绩；
输出成绩的升序、降序排序结果；
统计并输出及格（≥60）的人数。

2. 完整代码

python

运行

# 1. 初始化空列表 scores = [] # 2. 逐个添加成绩（append()） scores.append(85) scores.append(92) scores.append(78) scores.append(45) scores.append(59) # 3. 批量添加成绩（extend()） scores.extend([90, 88]) # 4. 输出完整成绩列表 print("=" * 30) print("完整成绩列表:", scores) # 5. 计算最高分、最低分（max()/min()） max_score = max(scores) min_score = min(scores) print(f"最高分: {max_score}") print(f"最低分: {min_score}") # 6. 计算平均分（sum()/len()） avg_score = sum(scores) / len(scores) print(f"平均分: {avg_score:.2f}") # 7. 筛选不及格成绩（列表推导式） fail_scores = [score for score in scores if score < 60] print(f"不及格的分数: {fail_scores}") # 8. 成绩排序（sorted()） sorted_asc = sorted(scores) # 升序 sorted_desc = sorted(scores, reverse=True) # 降序 print(f"成绩升序排序: {sorted_asc}") print(f"成绩降序排序: {sorted_desc}") # 9. 统计及格人数（列表推导式+len()） pass_count = len([score for score in scores if score >= 60]) print(f"及格人数: {pass_count}") print("=" * 30)

3. 执行结果

plaintext

============================== 完整成绩列表: [85, 92, 78, 45, 59, 90, 88] 最高分: 92 最低分: 45 平均分: 76.71 不及格的分数: [45, 59] 成绩升序排序: [45, 59, 78, 85, 88, 90, 92] 成绩降序排序: [92, 90, 88, 85, 78, 59, 45] 及格人数: 5 ==============================

八、常见问题与注意事项

索引越界错误：访问的索引超出列表范围（如列表长度为 5，访问索引 5），会报错IndexError，需确保索引在0 ~ len(列表)-1之间。
列表可变与不可变元素：列表中的可变元素（如子列表）可直接修改，不可变元素（如数字、字符串）需通过索引重新赋值修改。
切片的 “左闭右开” 规则：切片[a:b]始终不包含索引 b 的元素，如需包含最后一个元素，可省略 end_index（如列表[a:]）。
列表推导式与循环的效率：列表推导式比传统 for 循环更高效（底层优化），处理大量数据时优先使用。
sorted()与reverse()的区别：sorted()返回新列表，原列表不变；reverse()原地修改列表，无返回值。