6.1 什么是列表？

在 Python 中，列表（List）是一种用于存储多个元素的有序集合，它是最常用的数据结构之一。列表中的元素可以是不同的数据类型，如整数、字符串、浮点数，甚至可以是另一个列表。

列表就像一个有序的 “容器”，我们可以往里面添加元素、删除元素、修改元素，也可以查看里面的元素。例如，我们可以用列表存储一个班级的学生姓名、一组商品的价格等。

6.2 列表的创建

列表使用方括号（[]）来表示，元素之间用逗号（,）分隔。创建列表的基本语法如下：

列表名 = [元素1, 元素2, 元素3, ...]

示例：

# 存储整数的列表

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

# 存储字符串的列表

fruits = ["apple", "banana", "orange"]

# 存储不同数据类型的列表

mixed = [10, "hello", 3.14, True]

# 空列表（不包含任何元素）

empty_list = []

# 列表中包含列表（嵌套列表）

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

6.3 访问列表元素

列表中的每个元素都有一个对应的位置编号，称为索引（Index）。我们可以通过索引来访问列表中的元素。

6.3.1 正向索引

Python 中列表的索引从0开始，即第一个元素的索引是0，第二个元素的索引是1，以此类推。

示例：

fruits = ["apple", "banana", "orange", "grape"]

# 访问第一个元素（索引0）

print(fruits[0]) # 输出：apple

# 访问第二个元素（索引1）

print(fruits[1]) # 输出：banana

# 访问第四个元素（索引3）

print(fruits[3]) # 输出：grape

6.3.2 反向索引

除了正向索引，Python 还支持反向索引，即从列表的末尾开始计数。最后一个元素的反向索引是-1，倒数第二个元素的反向索引是-2，以此类推。

示例：

fruits = ["apple", "banana", "orange", "grape"]

# 访问最后一个元素（反向索引-1）

print(fruits[-1]) # 输出：grape

# 访问倒数第二个元素（反向索引-2）

print(fruits[-2]) # 输出：orange

# 访问第一个元素（反向索引-4）

print(fruits[-4]) # 输出：apple

6.3.3 索引越界

如果使用的索引超出了列表的范围（即索引值大于等于列表长度，或反向索引的绝对值大于列表长度），会导致 “索引越界” 错误（IndexError）。

示例：

fruits = ["apple", "banana", "orange"]

# 列表长度为3，最大正向索引是2

print(fruits[3]) # 会报错：IndexError: list index out of range

6.4 列表的切片

切片（Slice）是指从列表中截取一部分元素，形成一个新的列表。切片的语法如下：

列表名[start:stop:step]

• start：起始索引（包含该索引对应的元素，可选，默认从 0 开始）。

• stop：结束索引（不包含该索引对应的元素，必须指定）。

• step：步长（可选，默认是 1，即每次取一个元素；步长为负数表示反向切片）。

示例：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 截取索引1到4的元素（包含1，不包含4）

print(numbers[1:4]) # 输出：[1, 2, 3]

# 截取从索引2开始到末尾的元素

print(numbers[2:]) # 输出：[2, 3, 4, 5, 6, 7, 8, 9]

# 截取从开头到索引5的元素（不包含5）

print(numbers[:5]) # 输出：[0, 1, 2, 3, 4]

# 步长为2，截取索引0到8的元素

print(numbers[0:8:2]) # 输出：[0, 2, 4, 6]

# 反向切片（步长为-1），从末尾到开头

print(numbers[::-1]) # 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

6.5 修改列表元素

列表是可变的（Mutable），这意味着我们可以修改列表中的元素。修改元素的方法很简单，通过索引找到要修改的元素，然后重新赋值即可。

示例：

fruits = ["apple", "banana", "orange"]

# 修改索引1的元素

fruits[1] = "pear"

print(fruits) # 输出：["apple", "pear", "orange"]

# 修改最后一个元素（反向索引-1）

fruits[-1] = "grape"

print(fruits) # 输出：["apple", "pear", "grape"]

6.6 列表的常用操作

6.6.1 添加元素

1. append()：在列表的末尾添加一个元素。

numbers = [1, 2, 3]

numbers.append(4)

print(numbers) # 输出：[1, 2, 3, 4]

2. insert()：在指定索引位置插入一个元素。

numbers = [1, 2, 3]

# 在索引1的位置插入元素10

numbers.insert(1, 10)

print(numbers) # 输出：[1, 10, 2, 3]

3. extend()：将另一个可迭代对象（如列表、字符串）中的元素添加到当前列表的末尾。

list1 = [1, 2, 3]

list2 = [4, 5, 6]

list1.extend(list2)

print(list1) # 输出：[1, 2, 3, 4, 5, 6]

# 也可以用加号（+）拼接两个列表，返回一个新列表

list3 = list1 + list2

print(list3) # 输出：[1, 2, 3, 4, 5, 6, 4, 5, 6]

6.6.2 删除元素

1. del：根据索引删除元素，也可以删除整个列表。

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

# 删除索引2的元素

del numbers[2]

print(numbers) # 输出：[1, 2, 4, 5]

# 删除索引1到3的元素（切片删除）

del numbers[1:3]

print(numbers) # 输出：[1, 5]

2. remove()：根据元素值删除第一个匹配的元素（如果元素不存在，会报错）。

fruits = ["apple", "banana", "orange", "banana"]

# 删除第一个"banana"

fruits.remove("banana")

print(fruits) # 输出：["apple", "orange", "banana"]

3. pop()：删除并返回指定索引的元素（默认删除最后一个元素）。

numbers = [10, 20, 30, 40]

# 删除最后一个元素

last = numbers.pop()

print(last) # 输出：40

print(numbers) # 输出：[10, 20, 30]

# 删除索引1的元素

second = numbers.pop(1)

print(second) # 输出：20

print(numbers) # 输出：[10, 30]

6.6.3 其他常用操作

1. len()：获取列表的长度（即元素的个数）。

fruits = ["apple", "banana", "orange"]

print(len(fruits)) # 输出：3

2. count()：统计指定元素在列表中出现的次数。

numbers = [1, 2, 2, 3, 3, 3]

print(numbers.count(2)) # 输出：2（元素2出现了2次）

print(numbers.count(3)) # 输出：3（元素3出现了3次）

3. sort()：对列表进行排序（默认升序，会修改原列表）。

numbers = [3, 1, 4, 1, 5, 9]

numbers.sort()

print(numbers) # 输出：[1, 1, 3, 4, 5, 9]

# 降序排序

numbers.sort(reverse=True)

print(numbers) # 输出：[9, 5, 4, 3, 1, 1]

4. reverse()：反转列表中的元素（会修改原列表）。

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

numbers.reverse()

print(numbers) # 输出：[5, 4, 3, 2, 1]

6.7 列表推导式

列表推导式（List Comprehension）是一种简洁的创建列表的方式，它可以用一行代码生成一个新的列表。语法如下：

[表达式 for 变量 in 可迭代对象 if 条件表达式]

列表推导式的执行过程是：遍历可迭代对象中的每个元素，当条件表达式为True时，将表达式的结果添加到新列表中。

示例：

# 生成1到10的平方组成的列表

squares = [x **2 for x in range(1, 11)]

print(squares) # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 生成1到20中的偶数列表

evens = [x for x in range(1, 21) if x % 2 == 0]

print(evens) # 输出：[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# 将列表中的每个字符串转换为大写

fruits = ["apple", "banana", "orange"]

upper_fruits = [fruit.upper() for fruit in fruits]

print(upper_fruits) # 输出：["APPLE", "BANANA", "ORANGE"]

列表推导式比使用for循环和append()方法创建列表更简洁、高效。

6.8 示例：列表的综合应用

统计一个班级学生的成绩平均分，并找出最高分和最低分。

# 定义学生成绩列表

scores = [85, 92, 78, 90, 88, 76, 95, 89]

# 计算平均分

average = sum(scores) / len(scores) # sum()函数用于计算列表中元素的总和

# 找出最高分和最低分

highest = max(scores) # max()函数返回列表中的最大值

lowest = min(scores) # min()函数返回列表中的最小值

print(f"学生成绩：{scores}")

print(f"平均分：{average:.2f}") # .2f表示保留两位小数

print(f"最高分：{highest}")

print(f"最低分：{lowest}")

运行结果：

学生成绩：[85, 92, 78, 90, 88, 76, 95, 89]

平均分：86.62

最高分：95

最低分：76

6.9 小结

本章我们学习了 Python 中的列表，包括列表的创建、访问元素（正向索引和反向索引）、切片操作、修改元素，以及列表的常用操作（添加、删除、统计、排序等），还介绍了简洁高效的列表推导式。

列表是 Python 中非常灵活和常用的数据结构，它可以存储多个元素并支持各种操作，是处理批量数据的重要工具。在后续的学习中，我们会经常用到列表，结合循环和条件语句实现更复杂的功能。

下一章，我们将学习 Python 中的元组，它与列表有相似之处，但也有本质的区别。