Python学习--IndexError 详解

# 正向索引超出范围my_list = [10, 20, 30, 40, 50]print(f"列表长度: {len(my_list)}")print(f"有效索引范围: 0 到 {len(my_list)-1}")# 访问存在的索引print(my_list[0])  # 10print(my_list[4])  # 50# 访问不存在的正向索引try:    print(my_list[5])except IndexError as e:    print(f"错误: {e}")  # list index out of range# 访问不存在的负向索引try:    print(my_list[-6])except IndexError as e:    print(f"错误: {e}")  # list index out of range

# 空列表没有任何元素empty_list = []print(f"空列表长度: {len(empty_list)}")try:    print(empty_list[0])except IndexError as e:    print(f"空列表错误: {e}")try:    print(empty_list[-1])except IndexError as e:    print(f"负索引错误: {e}")

text = "Python"print(f"字符串: '{text}'")print(f"长度: {len(text)}")# 访问存在的字符print(f"索引0: {text[0]}")    # Pprint(f"索引5: {text[5]}")    # n# 访问不存在的索引try:    print(text[6])except IndexError as e:    print(f"字符串索引错误: {e}")# 负索引try:    print(text[-7])except IndexError as e:    print(f"负索引错误: {e}")

my_tuple = (1, 2, 3, 4, 5)print(f"元组: {my_tuple}")print(f"长度: {len(my_tuple)}")# 访问存在的索引print(my_tuple[2])  # 3# 访问不存在的索引try:    print(my_tuple[10])except IndexError as e:    print(f"元组索引错误: {e}")

def process_list(items):    """遍历列表时常见的索引错误"""    # 错误方式：使用固定的索引范围    items = [1, 2, 3]    try:        for i in range(len(items) + 1):  # 多循环一次            print(items[i])    except IndexError as e:        print(f"循环错误: {e}")    # 正确方式：使用 for 循环直接遍历    print("正确遍历:")    for item in items:        print(item)    # 或者使用 while 循环    i = 0    while i < len(items):        print(items[i])        i += 1process_list([1, 2, 3])

def remove_elements_error():    """在遍历时删除元素导致的索引错误"""    numbers = [1, 2, 3, 4, 5]    # 错误方式：遍历时删除元素    try:        for i in range(len(numbers)):            if numbers[i] % 2 == 0:                del numbers[i]  # 删除后列表变短，索引错位                print(f"删除后列表: {numbers}")    except IndexError as e:        print(f"错误: {e}")    # 正确方式：使用列表推导式    numbers = [1, 2, 3, 4, 5]    numbers = [x for x in numbers if x % 2 != 0]    print(f"正确删除后: {numbers}")remove_elements_error()

def nested_list_index():    """嵌套列表的索引访问"""    matrix = [        [1, 2, 3],        [4, 5, 6],        [7, 8, 9]    ]    # 正确的嵌套索引    print(matrix[1][2])  # 6    # 错误的行索引    try:        print(matrix[3][0])    except IndexError as e:        print(f"行索引错误: {e}")    # 错误的列索引    try:        print(matrix[1][5])    except IndexError as e:        print(f"列索引错误: {e}")nested_list_index()

def slice_operations():    """切片操作不会引发 IndexError"""    my_list = [1, 2, 3, 4, 5]    # 切片超出范围不会报错，只是返回空列表    print(my_list[10:20])    # []    print(my_list[-10:-5])   # []    # 部分超出范围仍能工作    print(my_list[3:10])     # [4, 5]    # 但直接索引超出范围会报错    try:        print(my_list[10])    except IndexError as e:        print(f"直接索引错误: {e}")slice_operations()

def safe_access_by_condition(lst, index):    """使用条件判断安全访问"""    if 0 <= index < len(lst):        return lst[index]    return None# 测试data = [10, 20, 30, 40, 50]print(safe_access_by_condition(data, 2))   # 30print(safe_access_by_condition(data, 10))  # Noneprint(safe_access_by_condition(data, -1))  # None

def safe_access_by_exception(lst, index, default=None):    """使用异常处理安全访问"""    try:        return lst[index]    except IndexError:        return default# 测试data = [10, 20, 30, 40, 50]print(safe_access_by_exception(data, 2))    # 30print(safe_access_by_exception(data, 10))   # Noneprint(safe_access_by_exception(data, -1))   # 50（负索引有效）print(safe_access_by_exception(data, -10, "超出范围"))  # 超出范围

# 对于字典，使用 get 方法my_dict = {'a': 1, 'b': 2, 'c': 3}print(my_dict.get('a'))       # 1print(my_dict.get('z'))       # Noneprint(my_dict.get('z', 0))    # 0（默认值）# 对于列表，可以自定义安全访问函数class SafeList:    """安全列表包装器"""    def __init__(self, data):        self.data = data    def get(self, index, default=None):        """安全获取元素"""        try:            return self.data[index]        except IndexError:            return default    def __getitem__(self, index):        """支持直接索引访问"""        return self.get(index)# 使用safe = SafeList([1, 2, 3, 4, 5])print(safe.get(2))      # 3print(safe.get(10))     # Noneprint(safe[2])          # 3print(safe[10])         # None（不会报错）

def negative_index_trap():    """负索引的常见陷阱"""    my_list = [1, 2, 3, 4, 5]    # 负索引从 -1 开始    print(my_list[-1])  # 5（最后一个）    print(my_list[-2])  # 4    print(my_list[-5])  # 1（第一个）    # 负索引超出范围    try:        print(my_list[-6])    except IndexError as e:        print(f"负索引错误: {e}")    # 安全访问负索引    def safe_negative_access(lst, index):        """安全访问负索引"""        if index < 0:            index = len(lst) + index        if 0 <= index < len(lst):            return lst[index]        return None    print(safe_negative_access(my_list, -1))   # 5    print(safe_negative_access(my_list, -6))   # Nonenegative_index_trap()

def dynamic_list_trap():    """动态列表操作的陷阱"""    numbers = [1, 2, 3, 4, 5]    # 错误：在循环中修改列表长度    i = 0    try:        while i < len(numbers):            if numbers[i] % 2 == 0:                del numbers[i]  # 删除后列表变短            else:                i += 1    except IndexError as e:        print(f"错误: {e}")    # 正确方法1：倒序遍历    numbers = [1, 2, 3, 4, 5]    for i in range(len(numbers) - 1, -1, -1):        if numbers[i] % 2 == 0:            del numbers[i]    print(f"倒序遍历删除: {numbers}")    # 正确方法2：使用列表推导式    numbers = [1, 2, 3, 4, 5]    numbers = [x for x in numbers if x % 2 != 0]    print(f"列表推导式: {numbers}")dynamic_list_trap()

import threadingimport timedef multi_thread_trap():    """多线程访问列表的陷阱"""    shared_list = list(range(10))    def remove_items():        """删除元素"""        for i in range(5):            if shared_list:                shared_list.pop()            time.sleep(0.01)    def access_items():        """访问元素"""        for i in range(10):            try:                value = shared_list[i]  # 可能引发 IndexError                print(f"访问到: {value}")            except IndexError:                print(f"索引 {i} 不存在")            time.sleep(0.01)    # 创建线程    t1 = threading.Thread(target=remove_items)    t2 = threading.Thread(target=access_items)    t1.start()    t2.start()    t1.join()    t2.join()# multi_thread_trap()  # 可能引发 IndexError# 解决方案：使用锁class ThreadSafeList:    """线程安全的列表"""    def __init__(self):        self._list = []        self._lock = threading.Lock()    def append(self, item):        with self._lock:            self._list.append(item)    def pop(self):        with self._lock:            if self._list:                return self._list.pop()            raise IndexError("列表为空")    def get(self, index):        with self._lock:            try:                return self._list[index]            except IndexError:                return None

def best_practice_enumerate():    """使用 enumerate 避免索引错误"""    items = ['a', 'b', 'c', 'd', 'e']    # 不好的做法    try:        for i in range(len(items) + 1):            print(items[i])    except IndexError as e:        print(f"索引错误: {e}")    # 好的做法：使用 enumerate    for index, item in enumerate(items):        print(f"{index}: {item}")    # 或者直接遍历    for item in items:        print(item)best_practice_enumerate()

def best_practice_slice():    """使用切片避免索引错误"""    data = [1, 2, 3, 4, 5]    # 不好的做法    def get_first_n_bad(n):        result = []        for i in range(n):            try:                result.append(data[i])            except IndexError:                break        return result    # 好的做法：使用切片    def get_first_n_good(n):        return data[:n]    print(get_first_n_bad(10))   # [1, 2, 3, 4, 5]    print(get_first_n_good(10))  # [1, 2, 3, 4, 5]best_practice_slice()

def best_practice_default():    """使用默认值避免索引错误"""    def safe_index(lst, index, default=None):        """安全获取列表元素"""        try:            return lst[index]        except IndexError:            return default    data = [10, 20, 30]    print(safe_index(data, 0))    # 10    print(safe_index(data, 5))    # None    print(safe_index(data, 5, 0)) # 0    # 使用字典存储数据    dict_data = {0: 10, 1: 20, 2: 30}    print(dict_data.get(0, 0))    # 10    print(dict_data.get(5, 0))    # 0best_practice_default()

def best_practice_boundary():    """检查边界条件"""    def process_adjacent_pairs(data):        """处理相邻元素对"""        if len(data) < 2:            return []        result = []        for i in range(len(data) - 1):  # 确保 i+1 存在            result.append(data[i] + data[i + 1])        return result    # 测试    print(process_adjacent_pairs([1, 2, 3, 4]))    # [3, 5, 7]    print(process_adjacent_pairs([1]))             # []    print(process_adjacent_pairs([]))              # []best_practice_boundary()