Python列表从索引到增删排序的全面解析

在Python中，列表（list）是一种用于存储元素的有序集合，支持索引、切片、增加、删除和排序等操作。下面将详细介绍如何从索引到增删排序系统地理解和操作Python列表。

1.列表是什么

列表由一系列按特定顺序排列的元素组成.你可以创建包含字母表中所有字母、数字0~9或
所有家庭成员姓名的列表;也可以将任何东西加入列表中,其中的元素之间可以没有任何关系.
鉴于列表通常包含多个元素,给列表指定一个表示复数的名称(如letters、digits或names)是个不错的主意.列表是 Python 内置的可变序列.它把多个对象按照确定的先后顺序放在一个容器中,并允许程序在运行期间修改这个容器.

在Python中,用方括号（[]）来表示列表,并用逗号来分隔其中的元素.下面是一个简单的列表示例,这个列表包含几种自行车：

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles)

如果你让Python将列表打印出来,Python将打印列表的内部表示,包括方括号：

方括号 [] 表示列表，元素之间使用逗号分隔.字符串在列表的表示形式中仍带引号,因为引号能让开发者看出它们是字符串,而不是变量名.

鉴于这不是你要让用户看到的输出,下面来学习如何访问列表元素.

1.1访问列表元素

列表是有序集合,因此要访问列表的任何元素,只需将该元素的位置或索引告诉Python即可.要访问列表元素,可指出列表的名称,再指出元素的索引,并将其放在方括号内.
例如,下面的代码从列表bicycles中提取第一款自行车：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])

上面演示了访问列表元素的语法.当你请求获取列表元素时,Python只返回该元素,而不包括方括号和引号：

这正是你要让用户看到的结果——整洁、干净的输出.
你还可以对任何列表元素调用前面介绍的字符串方法.例如,可使用方法title()让元素’trek’的格式更整洁：

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles[0].title())

这个示例的输出与前一个示例相同,只是首字母T是大写的.

1.2索引从0而不是1开始

在Python中,第一个列表元素的索引为0,而不是1.在大多数编程语言中都是如此,这与列表操作的底层实现相关.如果结果出乎意料,请看看你是否犯了简单的差一错误.

第二个列表元素的索引为1.根据这种简单的计数方式,要访问列表的任何元素,都可将其位置减1,并将结果作为索引.例如,要访问第四个列表元素,可使用索引3.

下面的代码访问索引1和3处的自行车：

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles[1]) 
print(bicycles[3])

这些代码返回列表中的第二个和第四个元素:

Python为访问最后一个列表元素提供了一种特殊语法.通过将索引指定为-1,可让Python返回最后一个列表元素：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])

这些代码返回’specialized’.这种语法很有用,因为你经常需要在不知道列表长度的情况下访问最后的元素.这种约定也适用于其他负数索引,例如,索引-2返回倒数第二个列表元素,索引-3返回倒数第三个列表元素,以此类推.

1.3使用列表中的各个值

可像使用其他变量一样使用列表中的各个值.例如,你可以使用拼接根据列表中的值来创建
消息.下面来尝试从列表中提取第一款自行车,并使用这个值来创建一条消息：

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
message = "My first bicycle was a " + bicycles[0].title() + "." 
print(message)

我们使用bicycles[0]的值生成了一个句子,并将其存储在变量message中.输出是一个简单的句子,其中包含列表中的第一款自行车：

2.修改、添加和删除元素

你创建的大多数列表都将是动态的,这意味着列表创建后,将随着程序的运行增删元素.例如,你创建一个游戏,要求玩家射杀从天而降的外星人;为此,可在开始时将一些外星人存储在列表中,然后每当有外星人被射杀时,都将其从列表中删除,而每次有新的外星人出现在屏幕上时,都将其添加到列表中.在整个游戏运行期间,外星人列表的长度将不断变化.

2.1修改列表元素

修改列表元素的语法与访问列表元素的语法类似.要修改列表元素,可指定列表名和要修改的元素的索引,再指定该元素的新值.
例如,假设有一个摩托车列表,其中的第一个元素为’honda’,如何修改它的值呢？

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
motorcycles[0] = 'ducati' 
print(motorcycles)

我们首先定义一个摩托车列表,其中的第一个元素为’honda’.接下来,我们将第一个元素的值改为’ducati’.输出表明,第一个元素的值确实变了,但其他列表元素的值没变：

你可以修改任何列表元素的值,而不仅仅是第一个元素的值.

2.2在列表中添加元素

你可能出于众多原因要在列表中添加新元素,例如,你可能希望游戏中出现新的外星人、添
加可视化数据或给网站添加新注册的用户.Python提供了多种在既有列表中添加新数据的方式.

1.在列表末尾添加元素
在列表中添加新元素时,最简单的方式是将元素附加到列表末尾.给列表附加元素时,它将添加到列表末尾.继续使用前一个示例中的列表,在其末尾添加新元素’ducati’：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
motorcycles.append('ducati') 
print(motorcycles)

方法append()将元素’ducati’添加到了列表末尾,而不影响列表中的其他所有元素：

方法append()让动态地创建列表易如反掌,例如,你可以先创建一个空列表,再使用一系列的
append()语句添加元素.下面来创建一个空列表,再在其中添加元素’honda’、‘yamaha’和’suzuki’：

motorcycles = [] 
motorcycles.append('honda') 
motorcycles.append('yamaha') 
motorcycles.append('suzuki') 
print(motorcycles)

这种创建列表的方式极其常见,因为经常要等程序运行后,你才知道用户要在程序中存储哪些数据.为控制用户,可首先创建一个空列表,用于存储用户将要输入的值,然后将用户提供的每个新值附加到列表中.

2.在列表中插入元素

使用方法insert()可在列表的任何位置添加新元素.为此,你需要指定新元素的索引和值.

motorcycles = ['honda', 'yamaha', 'suzuki'] 
motorcycles.insert(0, 'ducati') 
print(motorcycles)

在这个示例中,值’ducati’被插入到了列表开头;方法insert()在索引0处添加空间,并将值’ducati’存储到这个地方.这种操作将列表中既有的每个元素都右移一个位置：

2.3从列表中删除元素

你经常需要从列表中删除一个或多个元素.例如,玩家将空中的一个外星人射杀后,你很可能要将其从存活的外星人列表中删除;当用户在你创建的Web应用中注销其账户时,你需要将该用户从活跃用户列表中删除.你可以根据位置或值来删除列表中的元素.

1.使用del语句删除元素
如果知道要删除的元素在列表中的位置,可使用del语句.

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
del motorcycles[0] 
print(motorcycles)

上面代码使用del删除了列表motorcycles中的第一个元素——‘honda’：

使用del可删除任何位置处的列表元素,条件是知道其索引.下例演示了如何删除前述列表中的第二个元素——‘yamaha’：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles)
del motorcycles[1] 
print(motorcycles)

下面的输出表明,已经将第二款摩托车从列表中删除了：

在这两个示例中,使用del语句将值从列表中删除后,你就无法再访问它了.

2.使用方法pop()删除元素
有时候,你要将元素从列表中删除,并接着使用它的值.例如,你可能需要获取刚被射杀的外星人的x和y坐标,以便在相应的位置显示爆炸效果;在Web应用程序中,你可能要将用户从活跃成员列表中删除,并将其加入到非活跃成员列表中.

方法pop()可删除列表末尾的元素,并让你能够接着使用它.术语弹出(pop)源自这样的类比：列表就像一个栈,而删除列表末尾的元素相当于弹出栈顶元素.

下面从列表motorcycles中弹出一款摩托车：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
popped_motorcycle = motorcycles.pop() 
print(motorcycles) 
print(popped_motorcycle)

我们首先定义并打印了列表motorcycles.接下来,我们从这个列表中弹出一个值,并将其存储到变量popped_motorcycle中.然后我们打印这个列表,以核实从其中删除了一个值.最后,我们打印弹出的值,以证明我们依然能够访问被删除的值.输出表明,列表末尾的值’suzuki’已删除,它现在存储在变量popped_motorcycle中：

方法pop()是怎么起作用的呢？假设列表中的摩托车是按购买时间存储的,就可使用方法pop()打印一条消息,指出最后购买的是哪款摩托车：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
last_owned = motorcycles.pop() 
print("The last motorcycle I owned was a " + last_owned.title() + ".")

输出是一个简单的句子,指出了最新购买的是哪款摩托车:

3.弹出列表中任何位置处的元素
实际上,你可以使用pop()来删除列表中任何位置的元素,只需在括号中指定要删除的元素的索引即可.

motorcycles = ['honda', 'yamaha', 'suzuki'] 
first_owned = motorcycles.pop(0) 
print('The first motorcycle I owned was a ' + first_owned.title() + '.')

首先,我们弹出了列表中的第一款摩托车,然后打印了一条有关这辆摩托车的消息.输出是一个简单的句子,描述了我购买的第一辆摩托车：

别忘了,每当你使用pop()时,被弹出的元素就不再在列表中了.如果你不确定该使用del语句还是pop()方法,下面是一个简单的判断标准：如果你要从列表中删除一个元素,且不再以任何方式使用它,就使用del语句;如果你要在删除元素后还能继续使用它,就使用方法pop().

4.根据值删除元素
有时候,你不知道要从列表中删除的值所处的位置.如果你只知道要删除的元素的值,可使用方法remove().例如,假设我们要从列表motorcycles中删除值’ducati’.

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati'] 
print(motorcycles) 
motorcycles.remove('ducati') 
print(motorcycles)

上面代码让Python确定’ducati’出现在列表的什么地方,并将该元素删除：

使用remove()从列表中删除元素时,也可接着使用它的值.下面删除值’ducati’,并打印一条消息,指出要将其从列表中删除的原因：

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles) 
too_expensive = 'ducati' 
motorcycles.remove(too_expensive) 
print(motorcycles) 
print("\nA " + too_expensive.title() + " is too expensive for me.")

定义列表后,我们将值’ducati’存储在变量too_expensive中.接下来,我们使用这个变量来告诉Python将哪个值从列表中删除.最后,值’ducati’已经从列表中删除,但它还存储在变量too_expensive中,让我们能够打印一条消息,指出将’ducati’从列表motorcycles中删除的原因：

3.组织列表

在你创建的列表中,元素的排列顺序常常是无法预测的,因为你并非总能控制用户提供数据
的顺序.这虽然在大多数情况下都是不可避免的,但你经常需要以特定的顺序呈现信息.有时候,你希望保留列表元素最初的排列顺序,而有时候又需要调整排列顺序.Python提供了很多组织列
表的方式,可根据具体情况选用.

3.1使用方法sort()对列表进行永久性排序

Python方法sort()让你能够较为轻松地对列表进行排序.假设你有一个汽车列表,并要让其中的汽车按字母顺序排列.为简化这项任务,我们假设该列表中的所有值都是小写的.

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
cars.sort()
print(cars)

方法sort()永久性地修改了列表元素的排列顺序.现在,汽车是按字母顺序排列的,再也无法恢复到原来的排列顺序：

你还可以按与字母顺序相反的顺序排列列表元素,为此,只需向sort()方法传递参数reverse=True.下面的示例将汽车列表按与字母顺序相反的顺序排列：

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True) 
print(cars)

同样,对列表元素排列顺序的修改是永久性的：

3.2使用函数sorted()对列表进行临时排序

要保留列表元素原来的排列顺序,同时以特定的顺序呈现它们,可使用函数sorted().函数sorted()让你能够按特定顺序显示列表元素,同时不影响它们在列表中的原始排列顺序.下面尝试对汽车列表调用这个函数.

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
print("Here is the original list:") 
print(cars) 
print("\nHere is the sorted list:") 
print(sorted(cars)) 
print("\nHere is the original list again:") 
print(cars)

我们首先按原始顺序打印列表,再按字母顺序显示该列表.以特定顺序显示列表后,我们进行核实,确认列表元素的排列顺序与以前相同.

注意,调用函数sorted()后,列表元素的排列顺序并没有变.如果你要按与字母顺序相反的顺序显示列表,也可向函数sorted()传递参数reverse=True.

3.3倒着打印列表

要反转列表元素的排列顺序,可使用方法reverse().假设汽车列表是按购买时间排列的,可轻松地按相反的顺序排列其中的汽车：

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
print(cars) 
cars.reverse() 
print(cars)

注意,reverse()不是指按与字母顺序相反的顺序排列列表元素,而只是反转列表元素的排列顺序：

方法reverse()永久性地修改列表元素的排列顺序,但可随时恢复到原来的排列顺序,为此只需对列表再次调用reverse()即可.

3.4确定列表的长度

使用函数len()可快速获悉列表的长度。在下面的示例中，列表包含4个元素，因此其长度为4：

>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4

在你需要完成如下任务时,len()很有用：确定还有多少个外星人未被射杀,需要管理多少项可视化数据,网站有多少注册用户等.

注意 Python计算列表元素数时从1开始,因此确定列表长度时,你应该不会遇到差一错误.

4.使用列表时避免索引错误

刚开始使用列表时,经常会遇到一种错误.假设你有一个包含三个元素的列表,却要求获取第四个元素：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles[3])

这将导致索引错误：

Python试图向你提供位于索引3处的元素,但它搜索列表motorcycles时,却发现索引3处没有
元素.鉴于列表索引差一的特征,这种错误很常见.有些人从1开始数,因此以为第三个元素的索引为3;但在Python中,第三个元素的索引为2,因为索引是从0开始的.

索引错误意味着Python无法理解你指定的索引.程序发生索引错误时,请尝试将你指定的索引减1,然后再次运行程序,看看结果是否正确.别忘了,每当需要访问最后一个列表元素时,都可使用索引-1.这在任何情况下都行之有效,即便你最后一次访问列表后,其长度发生了变化：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles[-1])

索引-1总是返回最后一个列表元素,这里为值’suzuki’：

仅当列表为空时,这种访问最后一个元素的方式才会导致错误：

motorcycles = [] 
print(motorcycles[-1])

列表motorcycles不包含任何元素,因此Python返回一条索引错误消息：

注意：发生索引错误却找不到解决办法时,请尝试将列表或其长度打印出来.列表可能与你以
为的截然不同,在程序对其进行了动态处理时尤其如此.通过查看列表或其包含的元素数,可帮助你找出这种逻辑错误.

5.原地修改、新列表与返回值

可以用下面的对照快速判断：

表达式	是否修改原列表	是否得到新列表	返回值
items.append(x)	是	否	None
items.insert(i, x)	是	否	None
items.remove(x)	是	否	None
items.sort()	是	否	None
items.reverse()	是	否	None
items.pop()	是	否	被移除元素
sorted(items)	否	是	新列表
items.copy()	否	是	新列表

这个表揭示了 Python API 的一个重要惯例：如果一个方法的主要作用是原地改变可变对象,通常不会同时返回该对象,以免让调用者误以为得到了独立副本.

6.列表的可变性、别名与浅复制

如果不理解对象共享,你会看到“明明只修改一个变量,另一个列表怎么也变了”的现象.

6.1赋值不会复制列表

original = ["A", "B"]
alias = original
alias.append("C")
print(original)  # ['A', 'B', 'C']
print(alias)     # ['A', 'B', 'C']
print(alias is original)  # True

alias = original 只让两个名称指向同一个列表对象.任何原地修改都会通过两个名称被观察到.

6.2copy()创建新的外层列表

original = ["A", "B"]
snapshot = original.copy()
snapshot.append("C")
print(original)  # ['A', 'B']
print(snapshot)  # ['A', 'B', 'C']
print(snapshot is original)  # False

切片 original[:] 也能生成浅复制,但 copy() 更直接表达意图.

6.3浅复制只复制最外层容器

original = [[1], [2]]
shallow = original.copy()
shallow.append([3])
print(original)  # [[1], [2]]
shallow[0].append(99)
print(original)  # [[1, 99], [2]]

shallow 是新的外层列表,所以给它追加新的内层列表不会影响 original.但两个外层列表仍引用相同的原有内层列表,因此修改 shallow[0] 的内容会反映在 original[0] 中.

关系可以用 is 验证：

print(shallow is original)          # False
print(shallow[0] is original[0])    # True

需要完全独立复制嵌套结构时,应了解 copy.deepcopy();但深复制也不是通用默认方案,因为对象可能包含不可复制资源或有意共享的状态.首先应明确哪些层需要独立.

7.综合案例:维护文章发布清单

下面的脚本把创建、追加、插入、删除、排序、复制和安全取值串联起来.为了让重点留在列表上,任务用简单字符串表示.

tasks = ["编写正文", "生成配图", "检查代码"]
# 新任务默认追加到末尾；紧急任务插入开头。
tasks.append("补充参考资料")
tasks.insert(0, "核对教材范围")
# 在大规模修改前保存独立的外层快照。
snapshot = tasks.copy()
# 删除不再需要的任务；不存在时不把它当成错误。
cancelled_task = "制作视频"
if cancelled_task in tasks:
    tasks.remove(cancelled_task)
# 使用新列表生成展示顺序，不破坏实际执行顺序。
display_tasks = sorted(tasks, key=str.casefold)
print("展示顺序：", display_tasks)
print("执行顺序：", tasks)
# 完成并取走队首任务。小清单使用 pop(0) 足够清楚；
# 高频大型队列应考虑 collections.deque。
completed = tasks.pop(0) if tasks else None
print(f"已完成：{completed}" if completed else "暂无任务")
print("剩余任务：", tasks)
print("修改前快照：", snapshot)

预期输出：

展示顺序： ['核对教材范围', '检查代码', '生成配图', '编写正文', '补充参考资料']
执行顺序： ['核对教材范围', '编写正文', '生成配图', '检查代码', '补充参考资料']
已完成：核对教材范围
剩余任务： ['编写正文', '生成配图', '检查代码', '补充参考资料']
修改前快照： ['核对教材范围', '编写正文', '生成配图', '检查代码', '补充参考资料']

这个案例体现了几条工程原则：

• 实际顺序和展示顺序是不同需求,使用不同列表表达;
• sorted() 用于派生视图,避免意外改乱业务顺序;
• copy() 保存外层快照,但若元素本身可变,还要考虑浅复制边界;
• 删除前检查只适用于“不存在也正常”的场景;
• 访问或弹出前明确空列表行为.

8.分层练习

练习A:创建与访问

创建一个包含至少 5 种编程语言的列表：

1. 输出第一个、第三个和最后一个元素;
2. 使用负索引输出倒数第二个元素;
3. 用 f-string 生成一句包含其中某个元素的消息;
4. 写出所有合法正索引和负索引.

# 创建一个包含 5 种编程语言的列表
languages = ["Python", "Java", "C++", "JavaScript", "Go"]
# 1. 输出第一个、第三个和最后一个元素
print("第一个元素：", languages[0])
print("第三个元素：", languages[2])
print("最后一个元素：", languages[-1])
# 2. 使用负索引输出倒数第二个元素
print("倒数第二个元素：", languages[-2])
# 3. 使用 f-string 生成一句包含其中某个元素的消息
print(f"我最喜欢的编程语言是 {languages[0]}。")
# 4. 写出所有合法正索引和负索引
print("合法正索引：0, 1, 2, 3, 4")
print("合法负索引：-1, -2, -3, -4, -5")

练习B:增删改

从列表 ['需求分析', '编码', '测试'] 开始：

1. 把“编码”替换为“实现”;
2. 在开头插入“环境准备”;
3. 在末尾追加“发布”;
4. 使用 pop() 取出最后一步并保存;
5. 使用 remove() 删除“环境准备”;
6. 解释每一步是否改变列表长度.

steps = ["需求分析", "编码", "测试"]
# 初始列表
print("初始列表：", steps)
# 1. 把“编码”替换为“实现”
steps[1] = "实现"
print("替换后：", steps)
# 列表长度不变，因为只是修改元素
# 2. 在开头插入“环境准备”
steps.insert(0, "环境准备")
print("插入后：", steps)
# 列表长度 +1
# 3. 在末尾追加“发布”
steps.append("发布")
print("追加后：", steps)
# 列表长度 +1
# 4. 使用 pop() 取出最后一步并保存
last_step = steps.pop()
print("取出的最后一步：", last_step)
print("pop 后：", steps)
# 列表长度 -1
# 5. 使用 remove() 删除“环境准备”
steps.remove("环境准备")
print("删除后：", steps)
# 列表长度 -1
# 最终列表
print("最终列表：", steps)

练习C:append()与extend()

分别执行：

left = [1, 2]
left.append([3, 4])
right = [1, 2]
right.extend([3, 4])

比较两个列表的长度、元素结构和索引访问结果,说明“追加一个列表对象”与“追加列表中的元素”有什么区别.

# append()
left = [1, 2]
left.append([3, 4])
print("left =", left)
print("left 长度 =", len(left))
print("left[2] =", left[2])
print("left[2][0] =", left[2][0])

# extend()
right = [1, 2]
right.extend([3, 4])
print("right =", right)
print("right 长度 =", len(right))
print("right[2] =", right[2])
print("right[3] =", right[3])

核心区别
append() 是把整个对象当成 一个元素 添加进去：

[1, 2] + [[3, 4]]
→ [1, 2, [3, 4]]

所以：

• 长度是 3
• [3, 4] 整体是第 3 个元素
• left[2] 得到 [3, 4]
• left[2][0] 才得到 3

而 extend() 是把另一个列表里的元素 逐个加入：

[1, 2] + [3, 4]
→ [1, 2, 3, 4]

所以：

• 长度是 4
• 3 和 4 分别成为独立元素
• right[2] 是 3
• right[3] 是 4

一句话记忆：

append()：追加一个对象
extend()：追加多个元素

练习D:排序语义

给定：

places = ["Zurich", "beijing", "Amsterdam", "chengdu"]

1. 使用 sorted() 输出不区分大小写的升序结果;
2. 证明原列表未改变;
3. 使用 sort(reverse=True) 永久改变原列表;
4. 调用 reverse()，说明它与降序排序的区别.

places = ["Zurich", "beijing", "Amsterdam", "chengdu"]
# 1. sorted()：不区分大小写进行升序排序
result = sorted(places, key=str.lower)
print("排序结果：", result)
# 2. 证明原列表没有改变
print("原列表：", places)
# 3. sort(reverse=True)：直接修改原列表，降序排序
places.sort(reverse=True)
print("sort 降序后：", places)
# 4. reverse()：直接把当前列表顺序反转
places.reverse()
print("reverse 后：", places)

练习E:别名与浅复制

预测并验证：

original = [["A"], ["B"]]
alias = original
copy_1 = original.copy()
alias.append(["C"])
copy_1[0].append("X")

分别写出 original、alias、copy_1 的最终值,并用 is 解释原因.

original = [["A"], ["B"]]
alias = original
copy_1 = original.copy()
alias.append(["C"])
copy_1[0].append("X")
print("original =", original)
print("alias    =", alias)
print("copy_1   =", copy_1)
# 使用 is 验证对象关系
print("alias is original:", alias is original)
print("copy_1 is original:", copy_1 is original)
print("copy_1[0] is original[0]:", copy_1[0] is original[0])

练习F:主动制造错误

分别写出最小示例,触发并修复：

• 访问越界产生的 IndexError;
• 空列表 pop() 产生的 IndexError;
• 删除不存在值产生的 ValueError;
• 混合不可比较类型排序产生的 TypeError;
• 把 sort() 返回值赋给原变量导致的逻辑错误.

记录异常类型、出错行、根本原因和最小修复.

# 1. 访问越界 -> IndexError
numbers = [10, 20, 30]
try:
    print(numbers[3])          # 错误：最大合法索引是 2
except IndexError as e:
    print("1. IndexError:", e)
# 修复
print("修复后：", numbers[2])
# 2. 空列表 pop() -> IndexError
items = []
try:
    items.pop()
except IndexError as e:
    print("2. IndexError:", e)
# 修复
if items:
    items.pop()
else:
    print("修复后：列表为空，不执行 pop()")
# 3. 删除不存在的值 -> ValueError
fruits = ["apple", "banana"]
try:
    fruits.remove("orange")
except ValueError as e:
    print("3. ValueError:", e)
# 修复
if "orange" in fruits:
    fruits.remove("orange")
else:
    print("修复后：orange 不在列表中")
# 4. 混合不可比较类型排序 -> TypeError
data = [3, "2", 1]
try:
    data.sort()
except TypeError as e:
    print("4. TypeError:", e)
# 修复：统一转换成整数再排序
data = [3, "2", 1]
fixed_data = sorted(data, key=int)
print("修复后：", fixed_data)
# 5. 错误使用 sort() 的返回值
numbers = [3, 1, 2]
result = numbers.sort()
print("排序后的 numbers：", numbers)
print("sort() 的返回值：", result)
# 错误写法：
# numbers = numbers.sort()
# 这样 numbers 会变成 None
# 修复
numbers = [3, 1, 2]
numbers.sort()
print("修复后：", numbers)

练习G:小型阅读清单

设计一个阅读清单脚本,至少完成：

1. 添加一本书;
2. 把一本紧急阅读的书插入开头;
3. 完成并弹出第一本书;
4. 按书名不区分大小写生成展示列表;
5. 保存修改前快照;
6. 正确处理空清单.

# 创建阅读清单
reading_list = ["Python Crash Course", "Clean Code"]
# 5. 保存修改前快照
snapshot = reading_list.copy()
print("修改前快照：", snapshot)
# 1. 添加一本书
reading_list.append("Fluent Python")
print("添加后：", reading_list)
# 2. 把紧急阅读的书插入开头
reading_list.insert(0, "Effective Python")
print("插入紧急书籍后：", reading_list)
# 3. 完成并弹出第一本书
if reading_list:
    finished_book = reading_list.pop(0)
    print(f"已完成阅读：{finished_book}")
else:
    print("阅读清单为空，没有可完成的书。")
# 4. 按书名不区分大小写生成展示列表
display_list = sorted(reading_list, key=str.lower)
print("展示列表：")
for book in display_list:
    print("-", book)
# 验证快照没有被后续修改影响
print("修改前快照：", snapshot)
print("当前阅读清单：", reading_list)
# 6. 正确处理空清单
empty_list = []
if empty_list:
    finished = empty_list.pop(0)
    print("完成：", finished)
else:
    print("空清单：没有书可以弹出。")

9.总结:真正需要建立的列表思维

列表不仅是一对方括号,更是一套关于顺序、位置、状态变化与对象共享的模型.
学习完本文,应能准确解释：

1. 索引是从序列开头或末尾计算的位置偏移;
2. 列表是可变对象,许多方法会原地修改并返回 None;
3. del、pop() 和 remove() 分别表达不同的删除意图;
4. sort() 改原列表，sorted() 创建新列表,reverse() 不等于降序排序;
5. 赋值创建别名,不会复制列表;copy() 只创建浅复制;
6. IndexError 通常来自边界、空列表或程序状态与预期不一致;
7. 数据规模增大时,操作位置和数据结构会影响性能.