当前位置：首页 > news >正文

Python编程基础（二）| 列表简介

news 来源：原创 2025/6/3 23:16:37

引言：很久没有写 Python 了，有一点生疏。这是学习《Python 编程：从入门到实践（第3版）》的课后练习记录，主要目的是快速回顾基础知识。

练习1：姓名

将一些朋友的姓名存储在一个列表中，并将其命名为 names。依次访问该列表的每个元素，从而将每个朋友的姓名都打印出来。

# 定义一个包含朋友姓名的列表
names = ["张三", "李四", "王五", "赵六"]
# 通过索引访问并打印列表中的每个名字
# 注意：这里分别打印，更规范的“依次访问”通常会使用循环
print(names[0], names[1], names[2], names[-1])

张三 李四 王五 赵六

知识点回顾：

列表的创建：使用方括号 [] 定义列表，元素之间用逗号 , 分隔。
访问列表元素：通过索引（从0开始）访问列表中的特定元素，如 names[0]。
负数索引：-1 表示列表中的最后一个元素，-2 表示倒数第二个，以此类推。
print() 函数：可以接受多个参数，默认用空格分隔打印。

练习2：问候语

继续使用练习1中的列表，但不打印每个朋友的姓名，而是为每人打印一条消息。每条消息都包含相同的问候语，但抬头为相应朋友的姓名。

# 沿用练习1的列表
names = ["张三", "李四", "王五", "赵六"]
# 使用 f-string 为列表中的每位朋友打印个性化的问候语
print(f"{names[0]}，你好")
print(f"{names[1]}，你好")
# 使用负数索引访问倒数第二个元素
print(f"{names[-2]}，你好")
print(f"{names[-1]}，你好")

张三，你好
李四，你好
王五，你好
赵六，你好

知识点回顾：

f-string (格式化字符串字面量)：在字符串前加上 f，并用花括号 {} 嵌入变量或表达式，方便构建动态字符串。
列表元素的复用：列表中的数据可以被多次访问和使用。

练习3：自己的列表

想想你喜欢的通勤方式，如骑摩托车或开汽车，并创建一个包含多种通勤方式的列表。根据该列表打印一系列有关这些通勤方式的陈述，如下所示。

I would like to own a Honda motorcycle. (示例输出)

# 创建一个包含通勤方式的列表
commuting_mode = ["骑自行车","坐公交","开汽车"]
# 使用 f-string 打印关于这些通勤方式的陈述
# 示例是每个元素一条陈述，这里将多个喜好合并到一条语句中
print(f"我喜欢{commuting_mode[0]}，也喜欢{commuting_mode[1]}，但不喜欢{commuting_mode[2]}")

我喜欢骑自行车，也喜欢坐公交，但不喜欢开汽车

知识点回顾：

列表的灵活性：可以存储任何类型的数据，如字符串描述的通勤方式。
f-string的应用：将列表元素嵌入到描述性语句中。
根据需求组织输出：虽然书本示例是每项一个陈述，但这里根据个人偏好组合成了一句。如果想实现示例效果，通常会用循环。

练习4：嘉宾名单

如果你可以邀请任何人一起共进晚餐（无论是在世的还是故去的），你会邀请哪些人？请创建一个列表，其中包含至少三个你想邀请的人，然后使用这个列表打印消息，邀请这些人都来与你共进晚餐。

# 创建一个包含至少三位嘉宾的列表
guests = ["孙悟空","猪八戒","沙和尚"]
# 使用 f-string 打印邀请信息，将所有嘉宾包含在一条消息中
print(f"{guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭")

孙悟空，猪八戒，沙和尚，请你们吃饭

知识点回顾：

列表的创建与初始化。
f-string 组合列表元素进行输出。
练习目标：熟悉列表的基本操作和字符串格式化。

练习5：修改嘉宾名单

你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。

以完成练习4时编写的程序为基础，在程序末尾添加函数调用 print()，指出哪位嘉宾无法赴约。
修改嘉宾名单，将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。
再次打印一系列消息，向名单中的每位嘉宾发出邀请。

guests = ["孙悟空","猪八戒","沙和尚"]
print(f"{guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭")# 指出无法赴约的嘉宾
unable_to_attend = guests[2] # 假设沙和尚不能来
print(f"{unable_to_attend}不能来")# 修改嘉宾名单，替换无法赴约的嘉宾
guests[2] = "唐僧"
# 再次打印邀请信息
print(f"{guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭")

孙悟空，猪八戒，沙和尚，请你们吃饭
沙和尚不能来
孙悟空，猪八戒，唐僧，请你们吃饭

知识点回顾：

修改列表元素：通过索引直接给列表中的某个位置赋新值，如 guests[2] = "唐僧"。
变量的中间存储：可以将列表元素的值赋给另一个变量（如 unable_to_attend）以便后续使用。

练习6：添加嘉宾

你刚找到了一张更大的餐桌，可容纳更多的嘉宾就座。请想想你还想邀请哪三位嘉宾。

以完成练习4或练习5时编写的程序为基础，在程序末尾添加函数调用 print()，指出你找到了一张更大的餐桌。
使用 insert() 将一位新嘉宾添加到名单开头。
使用 insert() 将另一位新嘉宾添加到名单中间。
使用 append() 将最后一位新嘉宾添加到名单末尾。
打印一系列消息，向名单中的每位嘉宾发出邀请。

# 基于练习5的代码
guests = ["孙悟空","猪八戒","沙和尚"]
# print(f"{guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭") # 初始邀请（可选重复打印）unable_to_attend = guests[2]
# print(f"{unable_to_attend}不能来") # 声明无法赴约 （可选重复打印）
guests[2] = "唐僧"
print(f"初始名单更新后: {guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭") # 打印当前名单的邀请print("找到了一个更大的餐桌，所以可以邀请更多的人")# 添加新嘉宾
guests.insert(0,"牛魔王")   # 添加到名单开头
guests.insert(2,"蜘蛛精") # 添加到名单中间 (原索引1之后，现索引2的位置)
guests.append("白骨精")   # 添加到名单末尾# 打印新的邀请信息 (手动列出所有嘉宾)
print(f"{guests[0]}，{guests[1]}，{guests[2]}，{guests[3]}，{guests[4]}，{guests[5]}，请你们吃饭")
# 更通用的打印方式是使用循环：
# for guest in guests:
# print(f"{guest}，请你吃饭")

初始名单更新后: 孙悟空，猪八戒，唐僧，请你们吃饭
找到了一个更大的餐桌，所以可以邀请更多的人
牛魔王，孙悟空，蜘蛛精，猪八戒，唐僧，白骨精，请你们吃饭

知识点回顾：

list.insert(index, element)：在列表的指定 index 位置插入 element。原有元素及后续元素向后移动。
list.append(element)：将 element 添加到列表的末尾。
列表是动态的：可以随时添加或删除元素，其大小会相应改变。

练习7：缩短名单

你刚得知新购买的餐桌无法及时送达，因此只能邀请两位嘉宾。

以完成练习6时编写的程序为基础，在程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
使用 pop() 不断地删除名单中的嘉宾，直到只有两位嘉宾为止。每次从名单中弹出一位嘉宾时，都打印一条消息，让该嘉宾知道你很抱歉，无法邀请他来共进晚餐。
对于余下两位嘉宾中的每一位，都打印一条消息，指出他依然在受邀之列。
使用del将最后两位嘉宾从名单中删除，让名单变成空的。打印该名单，核实名单在程序结束时确实是空的。

# 基于练习6的代码
guests = ["孙悟空","猪八戒","沙和尚"]
guests[2] = "唐僧" # 完成替换
guests.insert(0,"牛魔王")
guests.insert(2,"蜘蛛精")
guests.append("白骨精")
# print(f"当前嘉宾名单: {guests}") # 可选，查看当前完整名单print("由于新餐桌无法即时送达，只能邀请两位")# 使用 pop() 删除嘉宾，直到只剩两位
# 初始有6位，需要pop掉4位
removed_guest1 = guests.pop() # 默认删除末尾元素
print(f"对不起，{removed_guest1}，由于新餐桌无法即时送达，无法邀请您来吃饭")
removed_guest2 = guests.pop()
print(f"对不起，{removed_guest2}，由于新餐桌无法即时送达，无法邀请您来吃饭")
removed_guest3 = guests.pop()
print(f"对不起，{removed_guest3}，由于新餐桌无法即时送达，无法邀请您来吃饭")
removed_guest4 = guests.pop()
print(f"对不起，{removed_guest4}，由于新餐桌无法即时送达，无法邀请您来吃饭")# 向余下的两位嘉宾发出邀请
print(f"{guests[0]}，请你吃饭")
print(f"{guests[1]}，请你吃饭")# 使用 del 删除名单中最后的两位嘉宾
del guests[0] # 删除第一位后，原第二位变成第一位
del guests[0] # 再次删除当前的第一位# 打印名单，核实已空
print(guests)

由于新餐桌无法即时送达，只能邀请两位
对不起，白骨精，由于新餐桌无法即时送达，无法邀请您来吃饭
对不起，唐僧，由于新餐桌无法即时送达，无法邀请您来吃饭
对不起，猪八戒，由于新餐桌无法即时送达，无法邀请您来吃饭
对不起，蜘蛛精，由于新餐桌无法即时送达，无法邀请您来吃饭
牛魔王，请你吃饭
孙悟空，请你吃饭
[]

知识点回顾：

list.pop()：移除并返回列表末尾的元素（无参数时）。
list.pop(index)：移除并返回列表中指定 index 处的元素。
del list_name[index]：根据索引删除列表中的元素。与 pop() 不同，del 不返回值。
循环删除：当需要根据条件（如列表长度）重复删除元素时，通常使用 while 循环配合 pop() 更为简洁，例如 while len(guests) > 2: ... guests.pop() ...。

练习8：放眼世界

想出至少5个你想去旅游的地方。
将这些地方存储在一个列表中，并确保其中的元素不是按字母顺序排列的。
按原始排列顺序打印该列表。
使用sorted()按字母顺序打印这个列表，不要修改它。
再次打印该列表，核实排列顺序未变。
使用sorted()按与字母顺序相反的顺序打印这个列表，不要修改它。
再次打印该列表，核实排列顺序未变。
使用reverse()修改列表元素的排列顺序。打印该列表，核实排列顺序确实变了。
使用reverse()再次修改列表元素的排列顺序。打印该列表，核实已恢复到原来的排列顺序。
使用sort()修改该列表，使其元素按字母顺序排列。打印该列表，核实排列顺序确实变了。
使用sort()修改该列表，使其元素按与字母顺序相反的顺序排列。打印该列表，核实排列顺序确实变了。

# 创建一个包含旅游地点的列表 (非字母顺序)
city = ["Shanghai", "Beijing", "Guangzhou", "Shenzhen", "Chengdu"]
print("原始列表:")
print(city)print("\n使用 sorted() 按字母顺序打印 (不修改原列表):")
print(sorted(city))
print("再次打印原列表，确认未变:")
print(city)print("\n使用 sorted() 按字母反序打印 (不修改原列表):")
print(sorted(city, reverse=True))
print("再次打印原列表，确认未变:")
print(city)print("\n使用 reverse() 修改列表顺序 (第一次):")
city.reverse() # 就地反转
print(city)print("\n使用 reverse() 再次修改列表顺序 (恢复):")
city.reverse() # 再次就地反转
print(city)print("\n使用 sort() 按字母顺序修改列表:")
city.sort() # 就地排序
print(city)print("\n使用 sort() 按字母反序修改列表:")
city.sort(reverse=True) # 就地反向排序
print(city)

原始列表:
['Shanghai', 'Beijing', 'Guangzhou', 'Shenzhen', 'Chengdu']使用 sorted() 按字母顺序打印 (不修改原列表):
['Beijing', 'Chengdu', 'Guangzhou', 'Shanghai', 'Shenzhen']
再次打印原列表，确认未变:
['Shanghai', 'Beijing', 'Guangzhou', 'Shenzhen', 'Chengdu']使用 sorted() 按字母反序打印 (不修改原列表):
['Shenzhen', 'Shanghai', 'Guangzhou', 'Chengdu', 'Beijing']
再次打印原列表，确认未变:
['Shanghai', 'Beijing', 'Guangzhou', 'Shenzhen', 'Chengdu']使用 reverse() 修改列表顺序 (第一次):
['Chengdu', 'Shenzhen', 'Guangzhou', 'Beijing', 'Shanghai']使用 reverse() 再次修改列表顺序 (恢复):
['Shanghai', 'Beijing', 'Guangzhou', 'Shenzhen', 'Chengdu']使用 sort() 按字母顺序修改列表:
['Beijing', 'Chengdu', 'Guangzhou', 'Shanghai', 'Shenzhen']使用 sort() 按字母反序修改列表:
['Shenzhen', 'Shanghai', 'Guangzhou', 'Chengdu', 'Beijing']

知识点回顾：

sorted(list) 函数：返回一个新的、已排序的列表副本，原列表不变。
sorted(list, reverse=True)：返回一个按反向顺序排序的新列表副本。
list.reverse() 方法：将列表中的元素就地反转（即直接修改原列表），不返回值。
list.sort() 方法：将列表中的元素就地按升序排序，不返回值。
list.sort(reverse=True) 方法：将列表中的元素就地按降序排序。
区分函数和方法：sorted() 是一个内置函数，它接受一个可迭代对象并返回新列表。.reverse() 和 .sort() 是列表对象的方法，它们直接修改列表本身。

练习9：晚餐嘉宾

选择你为完成练习4～练习7而编写的一个程序，在其中使用len()打印一条消息，指出你邀请了多少位嘉宾来共进晚餐。

# 使用练习4的初始嘉宾名单
guests = ["孙悟空","猪八戒","沙和尚"]
print(f"{guests[0]}，{guests[1]}，{guests[2]}，请你们吃饭")# 使用 len() 获取嘉宾数量并打印
number_of_guests = len(guests)
print(f"邀请了{number_of_guests}位客人")

孙悟空，猪八戒，沙和尚，请你们吃饭
邀请了3位客人

知识点回顾：

len(list) 函数：返回列表中元素的数量。

练习10：尝试使用各个函数

想想可存储到列表中的东西，如山川、河流、国家、城市、语言或你喜欢的任何东西。编写一个程序，在其中创建一个包含这些元素的列表。然后，至少把本章介绍的每个函数都使用一次来处理这个列表。

# 创建一个包含城市名称的列表
city = ["北京", "纽约", "巴黎", "东京", "伦敦"]
print(f"初始列表: {city}")# append(): 在列表末尾添加元素
city.append("香港")
print(f"append('香港')后: {city}")# insert(): 在指定位置插入元素
city.insert(1, "上海") # 在索引1处插入“上海”
print(f"insert(1, '上海')后: {city}")# del: 删除指定索引的元素
del city[-1] # 删除最后一个元素 "香港"
print(f"del city[-1]后: {city}")# pop(): 移除并返回列表末尾的元素
popped_city_end = city.pop()
print(f"pop()出的元素: {popped_city_end}")
print(f"pop()后列表: {city}")# pop(index): 移除并返回指定索引的元素
popped_city_index = city.pop(0) # 移除索引0的元素 "北京"
print(f"pop(0)出的元素: {popped_city_index}")
print(f"pop(0)后列表: {city}")# remove(): 根据值删除第一个匹配的元素
city.remove("东京") # 删除元素 "东京"
print(f"remove('东京')后: {city}")# sort(): 就地按字母（或数字）顺序排序
temp_city_for_sort = city[:] # 创建副本以保留原顺序用于后续sorted()演示
temp_city_for_sort.sort()
print(f"sort()后 (副本): {temp_city_for_sort}")
temp_city_for_sort.sort(reverse=True)
print(f"sort(reverse=True)后 (副本): {temp_city_for_sort}")# sorted(): 返回一个排序后的新列表，原列表不变
print(f"原列表 (用于sorted): {city}")
sorted_city = sorted(city)
print(f"sorted(city)结果: {sorted_city}")
print(f"原列表仍为: {city}")
sorted_city_reverse = sorted(city, reverse=True)
print(f"sorted(city, reverse=True)结果: {sorted_city_reverse}")
print(f"原列表仍为: {city}")# reverse(): 就地反转列表元素顺序
city.reverse()
print(f"reverse()后: {city}")# len(): 获取列表长度
print(f"当前列表长度 (len): {len(city)}")

初始列表: ['北京', '纽约', '巴黎', '东京', '伦敦']
append('香港')后: ['北京', '纽约', '巴黎', '东京', '伦敦', '香港']
insert(1, '上海')后: ['北京', '上海', '纽约', '巴黎', '东京', '伦敦', '香港']
del city[-1]后: ['北京', '上海', '纽约', '巴黎', '东京', '伦敦']
pop()出的元素: 伦敦
pop()后列表: ['北京', '上海', '纽约', '巴黎', '东京']
pop(0)出的元素: 北京
pop(0)后列表: ['上海', '纽约', '巴黎', '东京']
remove('东京')后: ['上海', '纽约', '巴黎']
sort()后 (副本): ['上海', '巴黎', '纽约']
sort(reverse=True)后 (副本): ['纽约', '巴黎', '上海']
原列表 (用于sorted): ['上海', '纽约', '巴黎']
sorted(city)结果: ['上海', '巴黎', '纽约']
原列表仍为: ['上海', '纽约', '巴黎']
sorted(city, reverse=True)结果: ['纽约', '巴黎', '上海']
原列表仍为: ['上海', '纽约', '巴黎']
reverse()后: ['巴黎', '纽约', '上海']
当前列表长度 (len): 3

(注：中文排序默认基于Unicode码点，可能与拼音顺序不同。此处的城市名排序结果是基于其实际字符的Unicode值。)

知识点回顾：

append(element): 在列表末尾添加元素。
insert(index, element): 在指定索引处插入元素。
del list[index]: 删除指定索引处的元素。
pop(): 移除并返回列表末尾的元素。
pop(index): 移除并返回指定索引处的元素。
remove(value): 移除列表中第一个值为 value 的元素。
sort(): 就地对列表进行排序（默认升序）。
sort(reverse=True): 就地对列表进行降序排序。
sorted(iterable): 返回一个新的已排序列表，原列表不变。
sorted(iterable, reverse=True): 返回一个新的已降序排序列表。
reverse(): 就地反转列表元素的顺序。
len(list): 返回列表中的元素数量。
列表切片创建副本：new_list = old_list[:] 可以用来创建一个列表的浅副本，这样对副本的操作不会影响原列表。

练习11：有意引发错误

如果你还没有在程序中遇到索引错误，就尝试引发一个这种错误吧。在你的一个程序中修改索引，以引发索引错误。在关闭程序前，务必消除这种错误。

# 创建一个列表
city = ["Shanghai", "Beijing", "Guangzhou", "Shenzhen", "Chengdu"]
# 列表长度为5，有效索引范围是 0 到 4 (或 -1 到 -5)# 尝试访问一个不存在的索引，这将引发 IndexError
# print(city[5]) # 索引5超出范围
# 或者
# print(city[6]) # 如原文所示，索引6同样超出范围# 以下是引发错误的代码示例：
# print(city[6])# 为了让程序能正常结束，我们将错误代码注释掉或修正
# 修正示例：访问一个有效索引
print(city[0])
# 或者，如果目的是显示错误，则在实际运行后注释掉引发错误的那行

# 当 print(city[6]) 未被注释时，会得到如下Traceback:
# Traceback (most recent call last):
#   File "<stdin>", line N, in <module>  (文件名和行号会变化)
# IndexError: list index out of range# 当执行修正后的代码 print(city[0]) 时，输出为:
Shanghai

知识点回顾：

IndexError: 当试图访问列表中不存在的索引时，Python会引发此错误。
列表索引范围：对于长度为 n 的列表，正向索引范围是 0 到 n-1，反向索引范围是 -1 到 -n。
错误处理与调试：理解常见的错误类型（如 IndexError）有助于更快地调试代码。在开发过程中，可以通过注释掉问题代码或使用 try-except 块来处理潜在的运行时错误。