Python序列的应用（七）：序列、列表
前言：在Python编程语言中，序列（Sequence）是一种基本且核心的数据结构，它允许我们以有序的方式存储和操作数据。序列可以包含不同类型的元素，并且支持通过索引来访问和修改这些元素。在Python中，最常见的序列类型包括列表（List）、元组（Tuple）、字符串（String）等。这些序列类型在数据处理、算法实现以及日常编程任务中扮演着至关重要的角色。
本系列教程的第七部分将专注于探讨序列中的两个关键概念：序列和列表。我们将从序列的基本概念出发，逐步深入到列表的创建、操作和应用。列表作为Python中最灵活和最常用的序列类型之一，它支持元素的动态添加、删除和修改，这使得列表在处理不确定数量的数据时显得尤为方便。
在本章节中，我们将覆盖以下内容：
- 序列的基本概念和特性。
- 列表的创建和初始化。
- 列表的索引和切片操作。
- 列表的常用操作，如添加、删除和修改元素。
- 列表推导式和生成器表达式。
- 列表的排序和搜索方法。
- 列表在实际编程中的应用案例。
通过本章节的学习，读者将能够掌握序列和列表的基础知识，以及如何在实际编程中有效地使用这些工具来解决各种问题。无论是进行数据分析、构建算法还是开发应用程序，序列和列表都是Python程序员不可或缺的技能。让我们开始这段学习之旅，深入探索Python序列和列表的奥秘。
一、序列
在Python中，序列（如列表、元组、字符串）的操作是非常基础且重要的。下面我将逐一解释这些操作，并提供示例代码。
1、 索引（Indexing）
索引用于访问序列中的单个元素。索引从0开始，-1表示最后一个元素。
# 示例：访问列表中的元素
my_list = [10, 20, 30, 40, 50]
print(my_list[0]) # 输出：10（第一个元素）
print(my_list[-1]) # 输出：50（最后一个元素）
2、切片（Slicing）
切片用于获取序列的一部分，返回一个新的序列。
# 示例：获取列表的一部分
my_list = [10, 20, 30, 40, 50]
print(my_list[1:5]) # 输出：[20, 30, 40, 50]（从索引1到索引4的元素）
print(my_list[:3]) # 输出：[10, 20, 30]（从开始到索引2的元素）
print(my_list[2:]) # 输出：[30, 40, 50]（从索引2到结束的元素）
3、序列相加（Concatenation）
序列相加是将两个序列连接起来，形成一个新的序列。
# 示例：连接两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2) # 输出：[1, 2, 3, 4, 5, 6]
4、 乘法（Repetition）
序列乘以一个整数，会将序列中的元素重复指定的次数。
# 示例：重复列表中的元素
list1 = [1, 2, 3]
print(list1 * 2) # 输出：[1, 2, 3, 1, 2, 3]
5、检查元素是否是序列的成员（Membership）
使用in关键字可以检查一个元素是否存在于序列中。
# 示例：检查元素是否在列表中
list1 = [1, 2, 3]
print(2 in list1) # 输出：True
print(4 in list1) # 输出：False
6、计算序列的长度（Length）
使用len()函数可以获取序列的长度。
# 示例：获取列表的长度
my_list = [10, 20, 30, 40, 50]
print(len(my_list)) # 输出：5
7.、计算最大值和最小值（Max and Min）
使用max()和min()函数可以分别获取序列中的最大值和最小值。
# 示例：获取列表中的最大值和最小值
my_list = [10, 20, 30, 40, 50]
print(max(my_list)) # 输出：50
print(min(my_list)) # 输出：10
内置函数表：
| 函数 | 作用 | 例子 | 结果 |
|---|---|---|---|
list() |
将序列转换为列表 | list((1, 2, 3)) |
[1, 2, 3] |
str() |
将序列转换为字符串 | str(123) |
'123' |
sum() |
计算元素总和 | sum([1, 2, 3, 4]) |
10 |
sorted() |
对元素进行排序 | sorted([3, 1, 4, 1, 5], reverse=True) |
[5, 4, 3, 1, 1] |
reversed() |
反向序列中的元素 | list(reversed([1, 2, 3, 4])) |
[4, 3, 2, 1] |
enumerate() |
将序列组合为一个索引序列，多用于for循环 | list(enumerate(['a', 'b', 'c'])) |
[(0, 'a'), (1, 'b'), (2, 'c')] |
这些函数在Python中非常常用，用于处理数据和执行常见的操作。
二、列表
Python 中的列表（list）是一种可变的序列类型，它允许你存储不同数据类型的元素，并且可以对这些元素进行增加、删除和修改等操作。下面是列表的一些常用操作及其示例：
1、列表的创建和删除
① 创建列表：使用方括号 [] 或 list() 函数。
my_list = [1, 2, 3, 'a', 'b']
# 或者
my_list = list((1, 2, 3, 'a', 'b'))
② 删除列表：使用 del 语句或 clear() 方法。
# 创建一个列表
my_list = [1, 2, 3]
print("原始列表:", my_list) # 输出原始列表
# 使用 clear 方法清空列表
my_list.clear()
print("清空后的列表:", my_list) # 输出 []
# 重新创建列表
my_list = [4, 5, 6]
print("重新创建的列表:", my_list) # 输出 [4, 5, 6]
# 使用 del 删除列表
del my_list
# 以下代码将引发 NameError，因为 my_list 已被删除
# print("删除后的列表:", my_list)
2、访问列表元素
通过索引访问列表中的元素。
my_list = [10, 20, 30, 40, 50]
# 输出第一个元素
print("第一个元素:", my_list[0]) # 输出 10
# 输出第三个元素
print("第三个元素:", my_list[2]) # 输出 30
# 输出最后一个元素
print("最后一个元素:", my_list[-1]) # 输出 50
# 输出倒数第三个元素
print("倒数第三个元素:", my_list[-3]) # 输出 30
实例训练18 -输出每日一帖
import datetime #导入日期时间类
#定义一个列表
mot =["今天星期一: \n坚持下去不是因为我很坚强,而是因为我别无选择。 ",
"今天星期二: \n含泪播种的人一定能笑着收获。 ",
"今天星期三: \n做对的事情比把事情做对重要。 ",
"今天星期四: \n命运给予我们的不是失望之酒,而是机会之杯。 ",
"今天星期五：\n不要等到明天,明天太遥远,今天就行动。",
"今天星期六: \n求知若饥,虚心若愚。 ",
"今天星期日: \n成功将属于那些从不说 “不可能” 的人。 "]
day=datetime.datetime.now().weekday() #获取当前星期
print(mot[day]) #输出每日一帖
3、遍历列表
使用 for 循环遍历列表中的每个元素。
my_list = ["apple", "banana", "cherry", "date"]
# 使用 for 循环遍历列表
for fruit in my_list:
print(fruit)
4、 添加、修改和删除列表元素
① 添加元素：
append(x)：在列表末尾添加一个元素。
# 创建一个列表
my_list = [1, 2, 3]
# 使用 append() 添加一个元素
my_list.append(4)
# 查看添加后的列表
print(my_list) # 输出: [1, 2, 3, 4]
insert(i, x)：在指定位置插入一个元素。
# 创建一个列表
my_list = [1, 2, 4]
# 使用 insert() 在索引 2 的位置插入元素 3
my_list.insert(2, 3)
# 查看插入后的列表
print(my_list) # 输出: [1, 2, 3, 4]
extend(iterable)或+：将一个可迭代对象的所有元素添加到列表末尾。
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 extend() 将 list2 的元素添加到 list1 的末尾
list1.extend(list2)
# 查看合并后的列表
print(list1) # 输出: [1, 2, 3, 4, 5, 6]
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 + 运算符合并两个列表
merged_list = list1 + list2
# 查看合并后的列表
print(merged_list) # 输出: [1, 2, 3, 4, 5, 6]
② 修改元素：通过索引直接赋值。
my_list[1] = 'x' # 将第二个元素修改为'x'
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 修改第二个元素（索引为 1）为 'x'
my_list[1] = 'x'
# 打印修改后的列表
print("修改后的列表:", my_list) # 输出结果: ['a', 'x', 'c', 'd']
③ 删除元素：
remove(x)：删除列表中第一个值为x的元素。
# 创建一个列表
my_list = [1, 2, 3, 4, 3]
# 使用 remove() 删除第一个值为 3 的元素
my_list.remove(3)
# 查看删除后的列表
print(my_list) # 输出: [1, 2, 4, 3]
pop([i])：删除并返回指定位置的元素，默认为最后一个。
# 创建一个列表
my_list = [1, 2, 3, 4]
# 使用 pop() 删除并返回索引为 2 的元素（第三个元素）
removed_element = my_list.pop(2)
# 查看删除后的列表
print("删除的元素:", removed_element) # 输出: 3
print("列表:", my_list) # 输出: [1, 2, 4]
del：删除指定位置的元素或切片。
# 创建一个列表
my_list = [1, 2, 3, 4]
# 使用 del 删除索引为 2 的元素（第三个元素）
del my_list[2]
# 查看删除后的列表
print(my_list) # 输出: [1, 2, 4]
5、对列表进行统计和计算
count(x)：返回x在列表中出现的次数。index(x[, start[, end]])：返回x在列表中第一次出现的索引。
下面是 count() 和 index() 方法在 Python 列表中进行统计和计算的示例：
① count(x)
count() 方法用于返回元素 x 在列表中出现的次数。
# 创建一个列表
my_list = [1, 2, 2, 3, 2, 4, 2]
# 使用 count() 计算元素 2 出现的次数
count_of_2 = my_list.count(2)
# 查看结果
print("元素 2 出现的次数:", count_of_2) # 输出: 4
② index(x[, start[, end]])
index() 方法用于返回元素 x 在列表中第一次出现的索引。如果元素不在列表中，会抛出一个 ValueError。可选参数 start 和 end 用于指定搜索的起始和结束位置。
# 创建一个列表
my_list = ['a', 'b', 'c', 'd', 'e']
# 使用 index() 查找元素 'c' 的索引
index_of_c = my_list.index('c')
# 查看结果
print("元素 'c' 的索引:", index_of_c) # 输出: 2
# 使用 index() 查找元素 'e' 在索引 3 之后的索引
index_of_e_after_3 = my_list.index('e', 3)
# 查看结果
print("元素 'e' 在索引 3 之后的索引:", index_of_e_after_3) # 输出: 4
# 如果尝试查找不存在的元素，`index()` 方法会抛出 `ValueError`：
# 尝试查找不存在的元素 'z'
try:
index_of_z = my_list.index('z')
except ValueError:
print("元素 'z' 不在列表中。")
输出将会是：
元素 'c' 的索引: 2
元素 'e' 在索引 3 之后的索引: 4
元素 'z' 不在列表中。
这些方法提供了对列表中元素的统计和定位功能，非常有用。
6、 对列表进行排序
sort()：对列表进行原地排序。sorted(iterable)：返回一个新的排好序的列表。
my_list.sort() # 原地排序
sorted_list = sorted(my_list, reverse=True) # 降序排序
下面是 sort() 方法和 sorted() 函数在 Python 中对列表进行排序的示例：
① sort() 方法
sort() 方法用于对列表进行原地（in-place）排序，即直接在原列表上进行排序，不返回新的列表。
# 创建一个列表
my_list = [3, 1, 4, 1, 5, 9, 2]
# 使用 sort() 方法对列表进行原地升序排序
my_list.sort()
# 查看排序后的列表
print("排序后的列表:", my_list) # 输出: [1, 1, 2, 3, 4, 5, 9]
如果你想对列表进行降序排序，可以使用 sort() 方法的 reverse 参数：
# 继续使用上面的列表
my_list.sort(reverse=True) # 原地降序排序
# 查看排序后的列表
print("降序排序后的列表:", my_list) # 输出: [9, 5, 4, 3, 2, 1, 1]
② sorted() 函数
sorted() 函数用于返回一个新的排好序的列表，它不会修改原始列表。
# 创建一个列表
my_list = [3, 1, 4, 1, 5, 9, 2]
# 使用 sorted() 函数返回一个新的升序排序的列表
sorted_list = sorted(my_list)
# 查看原始列表和新排序的列表
print("原始列表:", my_list) # 输出: [3, 1, 4, 1, 5, 9, 2]
print("新排序的列表:", sorted_list) # 输出: [1, 1, 2, 3, 4, 5, 9]
同样，如果你想进行降序排序，可以使用 sorted() 函数的 reverse 参数：
# 继续使用上面的列表
sorted_list_desc = sorted(my_list, reverse=True) # 返回一个新的降序排序的列表
# 查看新降序排序的列表
print("新降序排序的列表:", sorted_list_desc) # 输出: [9, 5, 4, 3, 2, 1, 1]
在这两个示例中，sort() 方法改变了原始列表，而 sorted() 函数返回了一个新的列表，原始列表保持不变。这允许你在需要时保留原始数据的顺序。
7、列表推导式
列表推导式提供了一种简洁的方式创建列表。
squares = [x**2 for x in range(10)]
列表推导式是 Python 提供的一种从其他列表构建新列表的简便方式，它通常用于应用简单的表达式或过滤条件。下面是一些列表推导式的示例：
示例 ①: 基础列表推导式
# 创建一个包含 0 到 9 的数字的平方的列表
squares = [x**2 for x in range(10)]
print(squares) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
示例 ②: 包含条件的列表推导式
# 创建一个包含 0 到 9 中偶数的平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出: [0, 4, 16, 36, 64]
示例 ③: 使用现有列表
# 假设有一个数字列表
numbers = [1, 2, 3, 4, 5]
# 创建一个新列表，包含原列表中每个数字的平方
squares = [x**2 for x in numbers]
print(squares) # 输出: [1, 4, 9, 16, 25]
示例 ④: 包含多个循环的列表推导式（嵌套列表推导式）
# 创建一个包含 0 到 2 的数字的所有可能组合的列表
combinations = [(x, y) for x in range(3) for y in range(3)]
print(combinations) # 输出: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
示例 ⑤: 包含条件和多个循环的列表推导式
# 创建一个包含 0 到 5 的数字的平方，但只包括大于 10 的数
squares_gt_10 = [x**2 for x in range(6) if x**2 > 10]
print(squares_gt_10) # 输出: [25]
列表推导式不仅代码更简洁，而且在很多情况下比等效的普通循环更快。它们是 Python 中非常强大和表达性的工具。
8、二维列表的使用
二维列表可以看作是列表的列表，常用于表示矩阵或表格数据。
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 访问第二行第三列的元素
print(matrix[1][2]) # 输出6
以下是更多关于二维列表使用的例子，涵盖了不同的常见操作，比如访问元素、修改元素、遍历列表等：
① 访问元素
# 定义一个表示学生成绩的二维列表，每行分别是不同学生的语文、数学、英语成绩
scores = [[80, 90, 85], [75, 88, 92], [90, 82, 78]]
# 访问第二个学生（索引为1）的数学成绩（索引为1）
math_score = scores[1][1]
print("第二个学生的数学成绩是：", math_score) #输出结果为 第二个学生的数学成绩是： 88
# 访问最后一个学生的英语成绩
last_student_english_score = scores[-1][-1]
print("最后一个学生的英语成绩是：", last_student_english_score) #输出结果为 最后一个学生的英语成绩是： 78
② 修改元素
# 还是以上面的学生成绩列表为例
scores = [[80, 90, 85], [75, 88, 92], [90, 82, 78]]
# 修改第一个学生的语文成绩（将原来的80修改为82）
scores[0][0] = 82
print("修改后的成绩列表：", scores) #输出的结果为 修改后的成绩列表： [[82, 90, 85], [75, 88, 92], [90, 82, 78]]
③ 遍历二维列表
方法一：使用嵌套的for循环（按行遍历）
scores = [[80, 90, 85], [75, 88, 92], [90, 82, 78]]
# 遍历成绩列表，输出每个学生的各科成绩
for row in scores:
for element in row:
print(element, end=" ")
print() # 换行，用于区分不同学生的成绩
#输出的结果为：
80 90 85
75 88 92
90 82 78
方法二：使用索引遍历（可以更灵活地控制遍历顺序等）
scores = [[80, 90, 85], [75, 88, 92], [90, 82, 78]]
# 通过索引遍历二维列表，输出每个位置的元素
for i in range(len(scores)):
for j in range(len(scores[i])):
print(scores[i][j], end=" ")
print()
#输出的结果为：
80 90 85
75 88 92
90 82 78
③ 二维列表的初始化
# 创建一个5行4列的二维列表，初始值都设为0，可用于表示一个5行4列的矩阵
matrix = [[0 for _ in range(4)] for _ in range(5)]
print(matrix) #输出的结果为： [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
④ 计算二维列表中元素的总和（以成绩列表为例）
scores = [[80, 90, 85], [75, 88, 92], [90, 82, 78]]
total_score = 0
for row in scores:
for element in row:
total_score += element
print("所有学生各科成绩总和是：", total_score) #输出的结果为：所有学生各科成绩总和是： 760
这些例子展示了二维列表在实际编程中多种使用场景和操作方式，方便处理类似矩阵、表格这类具有二维结构的数据。
9、 列表的切片
切片用于获取列表的一部分，返回一个新的列表。
print(my_list[1:3]) # 输出索引1到2的元素，结果为[2, 3]
print(my_list[:3]) # 输出从开始到索引2的元素
print(my_list[2:]) # 输出从索引2到结束的元素
列表切片是Python中非常强大的一个特性，它允许你获取列表的一部分，而不需要复制整个列表。以下是一些使用列表切片的例子：
① 基本切片：
my_list = [1, 2, 3, 4, 5]
# 输出索引1到2的元素（不包括索引3）
print(my_list[1:3]) # 输出 [2, 3]
② 从开头切片：
my_list = [1, 2, 3, 4, 5]
# 输出从列表开头到索引2的元素
print(my_list[:3]) # 输出 [1, 2, 3]
③ 从某点到末尾切片：
my_list = [1, 2, 3, 4, 5]
# 输出从索引2到列表末尾的元素
print(my_list[2:]) # 输出 [3, 4, 5]
④ 步长切片：
my_list = [1, 2, 3, 4, 5]
# 输出从索引0开始，每隔一个元素取一个，直到列表末尾
print(my_list[::2]) # 输出 [1, 3, 5]
⑤ 负步长切片：
my_list = [1, 2, 3, 4, 5]
# 输出列表的逆序
print(my_list[::-1]) # 输出 [5, 4, 3, 2, 1]
⑥ 负索引切片：
my_list = [1, 2, 3, 4, 5]
# 输出从索引 1 到列表末尾的第二个元素的元素（不包括列表末尾的第二个元素）
print(my_list[1:-2]) # 输出 [2, 3]
⑦ 复制整个列表：
my_list = [1, 2, 3, 4, 5]
# 复制整个列表
print(my_list[:]) # 输出 [1, 2, 3, 4, 5]
⑧ 在切片中使用步长：
my_list = [1, 2, 3, 4, 5]
# 输出从索引0开始，每隔两个元素取一个，直到列表末尾
print(my_list[0::2]) # 输出 [1, 3, 5]
⑨ 在切片中使用负步长：
my_list = [1, 2, 3, 4, 5]
# 输出从列表末尾的第二个元素开始，每隔一个元素取一个，直到列表开头
print(my_list[-2::-2]) # 输出 [4, 2]
⑩ 切片与赋值：
my_list = [1, 2, 3, 4, 5]
# 将索引1到2的元素替换为['a', 'b']
my_list[1:3] = ['a', 'b']
print(my_list) # 输出 [1, 'a', 'b', 4, 5]
①① 扩展列表：
my_list = [1, 2, 3, 4, 5]
# 在列表末尾扩展元素
my_list.extend([6, 7])
print(my_list) # 输出 [1, 'a', 'b', 4, 5, 6, 7]
①② 切片与列表推导式：
my_list = [1, 2, 3, 4, 5]
# 使用列表推导式创建一个新列表，包含原列表中每个元素的平方
quared_list = [x**2 for x in my_list]
print(squared_list) # 输出 [1, 9, 4, 16, 25]
这些例子展示了如何使用切片来获取列表的子集，以及如何利用切片的特性来进行更复杂的列表操作。
实例训练19 -使用二维列表输出不同版式的古诗
str1 = "生当作人杰"
str2 = "死亦为鬼雄"
str3 = "至今思项羽"
str4 = "不肯过江东"
verse = [list(str1), list(str2), list(str3), list(str4)] # 定义一个二维列表
print("\n-- 横版 --\n")
for i in range(4): # 循环古诗的每一行
for j in range(5): # 循环每一行的每个字(列)
if j == 4: # 如果是一行中的最后一个字
print(verse[i][j]) # 换行输出
else:
print(verse[i][j], end="") # 不换行输出
verse.reverse() # 对列表进行逆行排序
print("\n-- 竖版 --\n")
for i in range(5): # 循环每一行的每个字(列)
for j in range(4): # 循环新逆序排列后的第一行
if j == 3: # 如果是最后一行
print(verse[j][i]) # 换行输出
else:
print(verse[j][i], end="") # 不换行输出
这些操作涵盖了列表的基本使用，使得列表成为Python中非常灵活和强大的数据结构。
