列表切片为什么能取到部分元素？排序和查找又该怎么用？

小象实战讲义 · Python 编程从入门到实践

在前面的课时中，我们学习了列表的基本创建和元素访问，知道了如何获取单个元素。但在实际编程中，我们经常需要处理列表的一部分，比如“取前三个”、“取偶数位”或者“倒过来看”。本节将学习列表的切片操作，它能让你轻松截取列表的任意一段。同时，我们还会学习如何判断元素是否在列表中，以及如何对列表进行排序、反转和计数。这些操作是处理数据集合的基础。

💡 核心导读

• 切片：使用 [start:end:step] 语法截取列表的子集，理解“左闭右开”原则和负数索引。
• 成员判断：使用 in 和 not in 关键字快速检查元素是否存在于列表中。
• 排序与反转：使用 .sort() 对列表本身进行排序，使用 .reverse() 反转列表顺序。
• 计数：使用 .count() 统计列表中特定元素出现的次数。
• 关键区别：.sort() 会修改原列表，而切片等操作通常返回一个新列表。

什么是列表切片？

切片（Slicing）是一种通过指定开始位置、结束位置和步长来获取列表中部分元素的操作。其基本语法是 列表变量[开始:结束:步长]。这三个参数都可以省略。

核心规则：

1. 索引从0开始：列表中第一个元素的位置（索引）是0。
2. 左闭右开：切片区间包含“开始”索引对应的元素，但不包含“结束”索引对应的元素。
3. 负数索引：-1 表示最后一个元素，-2 表示倒数第二个，依此类推。
4. 步长：默认为1，表示逐个取元素；为2表示隔一个取一个；负数表示从右向左取。

基本切片与步长

下面把基本切片和步长放在同一个示例中演示。步长是切片的第三个参数，用第二个冒号分隔。

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("原始列表:", my_list)

# 1. 取从索引1（元素2）开始到列表末尾的所有元素
print("list[1:]:", my_list[1:])

# 2. 取从列表开头开始，到索引8（元素9）结束，但不包含索引8
print("list[:8]:", my_list[:8])

# 3. 取从索引3（元素4）开始，到索引5（元素6）结束，但不包含索引5
print("list[3:5]:", my_list[3:5])

# 4. 使用负数索引：取最后两个元素
print("list[-2:]:", my_list[-2:])

# 5. 开始位置(-2)在结束位置(-3)的右边，得到空列表
print("list[-2:-3]:", my_list[-2:-3])

# 6. 步长为2：取所有值为奇数的元素（索引0,2,4...）
print("list[::2]:", my_list[::2])

# 7. 从索引1到索引8，步长为2（取索引1,3,5,7的元素）
print("list[1:8:2]:", my_list[1:8:2])

# 8. 步长为负数：从最后一个元素开始，向左每隔一个取一个
print("list[-1::-2]:", my_list[-1::-2])

原始列表: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list[1:]: [2, 3, 4, 5, 6, 7, 8, 9, 10]
list[:8]: [1, 2, 3, 4, 5, 6, 7, 8]
list[3:5]: [4, 5]
list[-2:]: [9, 10]
list[-2:-3]: []
list[::2]: [1, 3, 5, 7, 9]
list[1:8:2]: [2, 4, 6, 8]
list[-1::-2]: [10, 8, 6, 4, 2]

如何判断元素是否在列表中？（in / not in）

我们可以使用 in 和 not in 关键字来检查某个元素是否存在于列表中。这是一个非常高效且常用的操作，返回布尔值（True 或 False）。

# 定义一个团队列表
group = ["唐僧", "悟空", "八戒", "沙僧", "白龙马", "白骨精"]

# 判断"白骨精"是否在团队中
if "白骨精" in group:
    print("猴哥快来！")
    # 判断"悟空"是否不在团队中
    if "悟空" not in group:
        pass  # 该分支不会执行：悟空在团队中
    else:
        print("老孙来也，妖怪哪里跑！")

猴哥快来！
老孙来也，妖怪哪里跑！

如何对列表排序和反转？

使用 .sort() 排序

.sort() 方法会直接修改原列表，将其中的元素按顺序排列。

• 默认按升序排列（从小到大）。
• 通过参数 reverse=True 可以改为降序排列（从大到小）。

使用 .reverse() 反转

.reverse() 方法会将列表中的元素顺序完全颠倒过来，它也会直接修改原列表。

num_list = [6, 2, 8, 13, 97]
print("排序前:", num_list)

num_list.sort()  # 默认升序
print("升序后:", num_list)

num_list.sort(reverse=True)  # 降序排列
print("降序后:", num_list)

# reverse() 直接反转原列表
num_list = [1, 2, 8, 1, 5, 1, 13, 97]
print("反转前:", num_list)

num_list.reverse()
print("反转后:", num_list)

排序前: [6, 2, 8, 13, 97]
升序后: [2, 6, 8, 13, 97]
降序后: [97, 13, 8, 6, 2]
反转前: [1, 2, 8, 1, 5, 1, 13, 97]
反转后: [97, 13, 1, 5, 1, 8, 2, 1]

如何统计列表中元素的出现次数？

使用 .count(元素) 方法可以统计指定元素在列表中出现的次数。如果元素不存在，则返回 0。

num_list = [1, 2, 8, 1, 5, 1, 13, 97]

# 统计数字 1 出现的次数
count_of_1 = num_list.count(1)
print("数字 1 出现了 {} 次".format(count_of_1))

# 统计数字 97 出现的次数
count_of_97 = num_list.count(97)
print("数字 97 出现了 {} 次".format(count_of_97))

# 统计一个不存在的数字
count_of_100 = num_list.count(100)
print("数字 100 出现了 {} 次".format(count_of_100))

数字 1 出现了 3 次
数字 97 出现了 1 次
数字 100 出现了 0 次

📝 动手练一练

1. 有一个列表 data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]，请使用切片完成以下操作：
   • 取出第3到第6个元素（即 30, 40, 50, 60）。
   • 取出最后三个元素。
   • 取出所有索引为奇数的元素（即 20, 40, 60, 80, 100）。
   • 将列表倒序输出。

data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 1. 第3到第6个元素：索引2到6（左闭右开）
print("第3到第6个元素:", data[2:6])

# 2. 最后三个元素：使用负数索引
print("最后三个元素:", data[-3:])

# 3. 索引为奇数的元素：从索引1开始，步长为2
print("索引为奇数的元素:", data[1::2])

# 4. 列表倒序：开始和结束省略，步长为-1
print("列表倒序:", data[::-1])

第3到第6个元素: [30, 40, 50, 60]
最后三个元素: [80, 90, 100]
索引为奇数的元素: [20, 40, 60, 80, 100]
列表倒序: [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

常见错误

小结

1. 切片 [start:end:step] 用于截取列表子集，遵循“左闭右开”原则，支持负数索引和步长。
2. in 和 not in 用于快速判断元素是否存在于列表中，返回布尔值。
3. .sort() 方法对列表进行原地排序，默认升序，reverse=True 可降序。
4. .reverse() 方法将列表元素顺序原地反转。
5. .count(x) 方法返回元素 x 在列表中出现的次数。
6. 注意区分原地修改的方法（如 .sort(), .reverse()）和返回新结果的操作（如切片）。

📋 行动清单

• 在Python环境中，将切片示例中的 start, end, step 换成不同的值，观察输出结果，加深对“左闭右开”和步长的理解。
• 对一个包含字符串的列表（如 ['apple', 'banana', 'cherry']）尝试使用 .sort() 和 .reverse()，看看排序规则。
• 使用 in 和 .count() 在一个混合了多种数据类型的列表中查找特定元素，体会它们的用途。

—— 小象教研组