MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python列表索引错误的常见案例

2021-09-134.9k 阅读

越界访问：正向索引超出范围

在Python中，列表是一种有序的可变数据类型。当我们使用正向索引来访问列表元素时，索引值是从0开始的。如果我们试图访问的索引值大于或等于列表的长度，就会引发 IndexError 错误。

简单的越界示例

my_list = [1, 2, 3]
print(my_list[3])

在上述代码中，my_list 的长度为3，有效的正向索引范围是0到2。当我们尝试访问 my_list[3] 时，由于索引3超出了列表的有效范围，Python会抛出 IndexError 错误，提示 list index out of range。

动态计算导致的越界

有时候，索引值不是直接写死的，而是通过动态计算得到的。这种情况下，更容易因为计算错误而导致越界访问。

def get_element(my_list, index):
    return my_list[index]

my_list = [10, 20, 30]
user_index = int(input("请输入一个索引值: "))
try:
    result = get_element(my_list, user_index)
    print(result)
except IndexError:
    print("索引超出范围")

在这段代码中，程序接受用户输入的索引值。如果用户输入的值大于或等于列表的长度，就会引发 IndexError 错误。在实际开发中，我们应该在使用用户输入的索引值之前，先对其进行有效性检查，比如使用 if 语句判断 user_index 是否在合法范围内。

越界访问：负向索引超出范围

Python列表也支持负向索引，负向索引从 -1 开始，表示从列表末尾开始计数。-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。然而，如果负向索引的绝对值大于列表的长度，同样会引发 IndexError 错误。

简单负向越界示例

my_list = [1, 2, 3]
print(my_list[-4])

在这个例子中，my_list 的长度为3，有效的负向索引范围是 -1 到 -3。当我们尝试访问 my_list[-4] 时，由于负向索引 -4 的绝对值大于列表长度，Python会抛出 IndexError 错误。

循环中负向索引越界

在循环中使用负向索引时，如果不小心也会导致越界错误。

my_list = [10, 20, 30]
index = -1
while True:
    try:
        print(my_list[index])
        index -= 1
    except IndexError:
        break

在上述代码中，我们通过不断减小负向索引值来遍历列表。当 index 减小到小于 -3（列表长度为3）时，就会引发 IndexError 错误，通过捕获这个错误，我们可以正确地结束循环。但如果没有进行错误处理，程序就会因为这个错误而终止。

空列表索引错误

当对一个空列表进行索引操作时，无论使用何种索引值，都会引发 IndexError 错误。这是因为空列表中没有任何元素，不存在可供访问的位置。

对空列表直接索引

empty_list = []
print(empty_list[0])

上述代码尝试访问空列表 empty_list 的第一个元素，由于列表为空，Python会抛出 IndexError 错误，提示 list index out of range。

函数中可能出现的空列表索引

在函数中，如果参数可能是一个空列表，而函数又对其进行索引操作，就容易出现错误。

def process_list(my_list):
    first_element = my_list[0]
    return first_element

my_empty_list = []
try:
    result = process_list(my_empty_list)
    print(result)
except IndexError:
    print("列表为空，无法获取第一个元素")

在这个函数 process_list 中，它假设传入的列表不为空，并试图获取列表的第一个元素。当传入一个空列表时，就会引发 IndexError 错误。在实际开发中，我们应该在函数内部对传入的列表进行检查，比如使用 if not my_list: 来判断列表是否为空，然后再进行相应的处理。

切片操作中的索引错误

虽然切片操作在一定程度上比直接索引更灵活，但如果切片的索引值设置不当，也会引发错误。

切片起始索引大于结束索引（非负数情况）

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[3:1]
print(sub_list)

在这个例子中，我们试图从索引3切片到索引1，由于起始索引3大于结束索引1，这样的切片操作会返回一个空列表，虽然不会引发 IndexError 错误，但这可能不是我们预期的结果。在大多数情况下，我们希望起始索引小于结束索引，这样才能得到有意义的切片结果。

切片起始索引大于列表长度

my_list = [1, 2, 3]
sub_list = my_list[5:7]
print(sub_list)

这里，起始索引5大于列表 my_list 的长度3。在Python中，这种情况下切片操作不会引发 IndexError 错误，而是会返回一个空列表。Python会将超出列表长度的索引值自动调整为列表的长度，所以 my_list[5:7] 相当于 my_list[3:3]，即空列表。

切片结束索引小于起始索引（负数情况）

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[-1:-3]
print(sub_list)

当使用负向索引进行切片时，如果结束索引的绝对值小于起始索引的绝对值，同样会返回一个空列表，不会引发 IndexError 错误。在这个例子中，my_list[-1:-3] 相当于从倒数第一个元素切片到倒数第三个元素，但由于顺序是从右向左，这样的切片不符合常规逻辑，所以返回空列表。

列表修改过程中的索引错误

在对列表进行修改操作时，比如插入、删除元素，索引值可能会因为列表结构的变化而变得无效，从而引发 IndexError 错误。

删除元素后索引错误

my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list[2])

在上述代码中，我们首先删除了 my_list 中索引为2的元素，此时列表变为 [1, 2, 4, 5]。之后再尝试访问 my_list[2]，原本索引2对应的元素已经改变，现在索引2对应的是新的元素4。如果我们没有意识到列表结构的变化，就可能会访问到错误的元素或者引发 IndexError 错误。

插入元素后索引错误

my_list = [1, 2, 3]
my_list.insert(1, 10)
print(my_list[3])

这里我们在 my_list 的索引1位置插入了元素10，列表变为 [1, 10, 2, 3]。如果我们之前的逻辑是基于插入元素前的列表结构，比如试图访问 my_list[3]，就可能会因为索引值没有根据列表的变化而调整，导致访问到错误的元素或者引发 IndexError 错误。在实际开发中，当对列表进行插入或删除操作后，应该重新审视后续对列表的索引操作，确保索引值的正确性。

嵌套列表索引错误

嵌套列表是指列表中的元素本身也是列表。在访问嵌套列表的元素时，需要注意多层索引的正确性，否则很容易引发 IndexError 错误。

外层列表索引越界

nested_list = [[1, 2], [3, 4]]
print(nested_list[2][0])

在这个嵌套列表中，外层列表的有效索引范围是0到1。当我们尝试访问 nested_list[2][0] 时，由于外层列表索引2超出范围，Python会抛出 IndexError 错误，提示 list index out of range。

内层列表索引越界

nested_list = [[1, 2], [3, 4]]
print(nested_list[0][2])

这里，虽然外层列表索引0是有效的，但内层列表 nested_list[0] 是 [1, 2]，其有效索引范围是0到1。当我们尝试访问 nested_list[0][2] 时，内层列表索引2超出范围，同样会引发 IndexError 错误。

动态访问嵌套列表的索引错误

在处理动态生成的嵌套列表时，索引错误更容易发生。

def create_nested_list(rows, cols):
    nested_list = []
    for _ in range(rows):
        sub_list = [0] * cols
        nested_list.append(sub_list)
    return nested_list

my_nested_list = create_nested_list(3, 2)
try:
    value = my_nested_list[2][2]
    print(value)
except IndexError:
    print("索引超出范围")

在上述代码中，create_nested_list 函数创建了一个3行2列的嵌套列表。如果我们之后试图访问 my_nested_list[2][2]，就会引发 IndexError 错误，因为内层列表的列数只有2，索引2超出了范围。在处理动态生成的嵌套列表时，我们需要清楚地知道列表的结构和每个维度的有效索引范围，在进行索引操作前，最好进行有效性检查。

循环中列表索引错误

在循环中操作列表时，如果对列表的索引处理不当，很容易引发 IndexError 错误。

for 循环中的索引错误

my_list = [1, 2, 3]
for i in range(len(my_list) + 1):
    print(my_list[i])

在这个 for 循环中，range(len(my_list) + 1) 会生成从0到列表长度的索引值。当 i 等于列表长度时，my_list[i] 就会引发 IndexError 错误，因为列表的有效索引范围是0到 len(my_list) - 1。为了避免这种错误，我们应该确保 range 函数生成的索引值在列表的有效范围内，即 for i in range(len(my_list))。

while 循环中的索引错误

my_list = [1, 2, 3]
index = 0
while index <= len(my_list):
    print(my_list[index])
    index += 1

在这个 while 循环中，当 index 等于列表长度时，同样会引发 IndexError 错误。我们应该将循环条件改为 while index < len(my_list)，这样才能保证在访问列表元素时不会越界。

循环中修改列表导致的索引错误

my_list = [1, 2, 3, 4, 5]
for i in range(len(my_list)):
    if my_list[i] % 2 == 0:
        del my_list[i]
    print(my_list[i])

在这个循环中，我们试图删除列表中的偶数元素。但是，当我们删除一个元素后，列表的长度会发生变化，而 i 的值仍然按照原来的索引顺序增加。这就导致在删除元素后，后续的索引值可能会越界。例如，当 i 为1时删除了元素2，此时列表变为 [1, 3, 4, 5]，但 i 会继续增加到2，而此时 my_list[2] 已经不是原来的元素4了，这样就可能引发 IndexError 错误。为了避免这种情况，可以使用列表推导式或者在删除元素后调整索引值。例如使用列表推导式来删除偶数元素：

my_list = [1, 2, 3, 4, 5]
my_list = [num for num in my_list if num % 2 != 0]
print(my_list)

这样就可以在不引发索引错误的情况下删除列表中的偶数元素。

列表推导式中的索引错误

列表推导式是一种简洁的创建列表的方式，但如果在列表推导式中使用索引操作不当，也会引发 IndexError 错误。

错误的索引引用

my_list = [1, 2, 3]
new_list = [my_list[i + 1] for i in range(len(my_list))]

在这个列表推导式中，my_list[i + 1] 试图访问 my_list 中当前索引 i 的下一个元素。当 i 等于列表长度减1时，i + 1 就会超出列表的有效范围，引发 IndexError 错误。为了避免这种情况，我们需要确保在列表推导式中使用的索引值在有效范围内。例如，如果我们只想获取相邻元素的差值，可以这样修改代码：

my_list = [1, 2, 3]
new_list = [my_list[i + 1] - my_list[i] for i in range(len(my_list) - 1)]
print(new_list)

这样，通过将 range(len(my_list) - 1)，我们确保了索引 i + 1 始终在有效范围内。

嵌套列表推导式中的索引错误

nested_list = [[1, 2], [3, 4]]
new_list = [nested_list[i][j + 1] for i in range(len(nested_list)) for j in range(len(nested_list[i]))]

在这个嵌套列表推导式中，nested_list[i][j + 1] 试图访问内层列表中当前索引 j 的下一个元素。当 j 等于内层列表长度减1时，j + 1 就会超出内层列表的有效范围，引发 IndexError 错误。同样，我们需要仔细检查索引值的有效性。例如，如果我们想获取内层列表中相邻元素的和，可以这样修改：

nested_list = [[1, 2], [3, 4]]
new_list = [nested_list[i][j] + nested_list[i][j + 1] for i in range(len(nested_list)) for j in range(len(nested_list[i]) - 1)]
print(new_list)

通过将内层 range(len(nested_list[i]) - 1)，我们确保了在访问内层列表元素时不会越界。

迭代器与列表索引错误

在Python中，迭代器提供了一种遍历数据集合的方式。当我们在使用迭代器的过程中同时进行列表索引操作时，如果处理不当，也可能引发 IndexError 错误。

迭代器与列表索引混合使用错误

my_list = [1, 2, 3]
my_iterator = iter(my_list)
for _ in range(len(my_list)):
    value1 = next(my_iterator)
    value2 = my_list[_ + 1]
    print(value1 + value2)

在这段代码中，我们同时使用了迭代器 my_iterator 和列表索引 my_list[_ + 1]。当 _ 等于列表长度减1时，my_list[_ + 1] 会引发 IndexError 错误。在实际开发中，我们应该避免在同一个逻辑中同时使用迭代器和列表索引进行遍历，除非我们非常清楚自己在做什么。如果只是简单的遍历并进行操作，使用迭代器或者列表索引其中一种方式就足够了。

迭代器耗尽后索引错误

my_list = [1, 2, 3]
my_iterator = iter(my_list)
for _ in range(len(my_list)):
    value = next(my_iterator)
print(my_list[0])

在这个例子中，虽然代码本身没有直接因为迭代器和索引的混合使用引发错误，但如果后续代码依赖于迭代器遍历后列表的状态，并且使用索引操作，可能会出现逻辑错误。例如，如果在迭代器耗尽后，我们假设列表的第一个元素还是原来的值，而实际上在迭代过程中列表可能已经被其他操作修改，那么使用 my_list[0] 就可能得到意外的结果。为了避免这种情况，在使用迭代器后，如果还需要对列表进行索引操作，应该先确保列表的状态符合预期，或者重新获取列表的引用。

函数调用与列表索引错误

在函数调用过程中，如果传递的列表参数以及函数内部对列表的索引操作处理不当，会引发 IndexError 错误。

函数参数列表为空引发的索引错误

def process_list(my_list):
    first = my_list[0]
    last = my_list[-1]
    return first + last

empty_list = []
try:
    result = process_list(empty_list)
    print(result)
except IndexError:
    print("列表为空，无法处理")

在这个 process_list 函数中，它假设传入的列表不为空，并试图获取列表的第一个和最后一个元素。当传入一个空列表时，就会引发 IndexError 错误。在编写函数时，应该对传入的列表参数进行有效性检查，比如在函数开头添加 if not my_list: return None 这样的语句，避免在空列表上进行索引操作。

函数返回列表索引错误

def get_sub_list(my_list):
    return my_list[1:3]

my_list = [1, 2, 3]
sub_list = get_sub_list(my_list)
print(sub_list[2])

在这个例子中，get_sub_list 函数返回了 my_list 的一个切片。如果调用者在使用返回的子列表时，没有考虑到子列表的长度，比如试图访问 sub_list[2]，而子列表的长度可能小于3，就会引发 IndexError 错误。在调用返回列表的函数后，调用者应该对返回的列表进行必要的检查，确保索引操作在有效范围内。

模块与列表索引错误

在Python项目中，不同模块之间可能会共享列表数据。如果在模块间传递和操作列表时，对列表索引处理不当，也会引发 IndexError 错误。

模块间传递空列表引发的索引错误

假设我们有两个模块 module1.py 和 module2.py。

module1.py

def send_list():
    return []

module2.py

from module1 import send_list

def process_received_list():
    received_list = send_list()
    value = received_list[0]
    return value

在 module2.py 中，process_received_list 函数调用 module1.py 中的 send_list 函数获取一个列表，然后试图访问列表的第一个元素。由于 send_list 返回的是一个空列表，这就会引发 IndexError 错误。在模块间传递列表时，模块的提供者和使用者都应该明确列表可能的状态，提供者可以在文档中说明返回列表的情况，使用者应该对接收到的列表进行有效性检查。

模块间修改列表导致的索引错误

module1.py

shared_list = [1, 2, 3]

def modify_shared_list():
    del shared_list[1]

module2.py

from module1 import shared_list, modify_shared_list

def access_shared_list():
    modify_shared_list()
    value = shared_list[1]
    return value

在这个例子中，module1.py 中的 modify_shared_list 函数修改了共享列表 shared_list，删除了索引为1的元素。module2.py 中的 access_shared_list 函数在调用 modify_shared_list 后，试图访问 shared_list[1]，但此时列表结构已经改变，原来的索引1对应的元素可能已经不存在，从而引发 IndexError 错误。在模块间共享列表时，需要注意列表结构的变化对索引操作的影响，最好通过函数接口来操作共享列表，并且在操作前后进行必要的索引有效性检查。

通过对以上各种Python列表索引错误常见案例的分析，我们可以更加深入地理解列表索引的原理和可能出现错误的地方，在实际编程中能够更加准确地避免和处理这些错误，提高代码的稳定性和可靠性。在处理列表索引时，始终要牢记列表的长度、索引的范围以及列表结构变化对索引的影响，进行充分的有效性检查和错误处理。