try:  
    # 可能会引发异常的代码  
    raise SystemExit("Exiting the program")  
except BaseException as e:  
    print(f"Caught an exception: {e}")

import sys  # 导入 sys 模块，它提供了访问与 Python 解释器紧密相关的变量和函数  
  
def main():  
    try:  
        # 尝试执行以下代码块  
        print("Starting the program...")  
          
        # 引发 SystemExit 异常，通常这会导致程序退出  
        # 这里的参数 "Exiting the program" 会作为退出状态码的描述（尽管在大多数操作系统上，只有状态码本身会被使用）  
        sys.exit("Exiting the program")    
          
        # 下面的代码将不会被执行，因为 sys.exit() 会导致程序退出  
        print("This line will not be executed.")  
      
    except SystemExit as e:  
        # 捕获 SystemExit 异常  
        # 注意：在大多数情况下，你不应该捕获 SystemExit 异常，因为它表示程序的正常退出  
        # 这里只是为了演示如何捕获它  
        print(f"Caught SystemExit: {e}")  
        # 如果不重新引发 SystemExit 异常，程序将继续运行  
        # 但通常，在捕获到 SystemExit 后，你应该考虑让程序正常退出，或者执行一些清理工作  
        # 然后重新引发异常或使用其他方式退出程序  
        # raise  # 如果取消注释这行代码，程序将在这里重新引发 SystemExit 异常并退出  
      
    finally:  
        # 无论是否发生异常，finally 块中的代码都会执行  
        # 这通常用于执行清理工作，如关闭文件、释放资源等  
        print("Cleaning up resources...")  
  
# 调用 main 函数来运行程序  
if __name__ == "__main__":  
    main()

Starting the program...  
Caught SystemExit: Exiting the program  
Cleaning up resources...

import time  # 导入time模块来处理时间相关的操作  
  
def long_running_task():  
    """  
    模拟一个长时间运行的任务。  
    这个函数会进入一个无限循环，直到被KeyboardInterrupt异常中断。  
    """  
    try:  
        while True:  # 无限循环  
            print("任务正在运行...")  # 打印任务正在运行的消息  
            time.sleep(1)  # 休眠1秒，模拟任务正在处理中  
    except KeyboardInterrupt:  # 捕捉KeyboardInterrupt异常  
        # 当用户按下Ctrl+C时，这个异常会被引发  
        print("\n用户中断了程序。")  # 打印一条消息通知用户程序已被中断  
        # 在这里可以添加任何你需要的清理代码  
  
if __name__ == "__main__":  
    # 调用长时间运行的任务函数  
    long_running_task()

任务正在运行...  
任务正在运行...  
任务正在运行...  
（用户按下Ctrl+C）  
  
用户中断了程序。

def divide_numbers(a, b):  
    """  
    这个函数接受两个数字作为参数，并返回它们的除法结果。  
    如果除数为零，则引发一个ZeroDivisionError异常，该异常是Exception的一个子类。  
    """  
    try:  
        # 尝试执行除法运算  
        result = a / b  
        return result  
    except ZeroDivisionError as e:  
        # 捕捉ZeroDivisionError异常  
        # 这里我们可以选择重新引发一个更通用的Exception异常，或者执行其他操作  
        # 但在这个例子中，我们直接打印一条错误消息  
        print(f"错误: 不能除以零 - {e}")  
        # 由于我们不想在这里处理完异常后继续返回结果，  
        # 所以我们可以选择不返回任何值（或者返回一个特殊的值来表示错误）  
        # 在这个例子中，我们简单地选择不返回任何值（即返回None）  
        # 注意：在实际应用中，最好避免函数在没有明确返回值的情况下返回None，  
        # 除非这是函数设计的一部分。  
        return None  
    except Exception as e:  
        # 捕捉所有其他从Exception继承的异常  
        # 注意：通常不推荐这样做，因为它会隐藏特定异常的处理逻辑  
        # 在这个例子中，我们只是为了演示如何捕捉所有异常  
        print(f"发生了一个未预料的异常: {e}")  
        return None  
  
# 测试函数  
if __name__ == "__main__":  
    # 正常情况  
    print(divide_numbers(10, 2))  # 应该打印: 5.0  
    # 引发ZeroDivisionError异常的情况  
    print(divide_numbers(10, 0))  # 应该打印: 错误: 不能除以零 - division by zero  
    # 我们可以添加更多测试来引发其他类型的异常，但在这个例子中我们保持简单  
    # 例如，如果我们尝试传递一个字符串作为除数，将会引发TypeError异常  
    # 但由于我们在except块中只捕捉了ZeroDivisionError和Exception，  
    # TypeError将不会被这个特定的except块捕捉（除非我们添加了对TypeError的捕捉）  
    # print(divide_numbers(10, "a"))  # 这将引发TypeError，但不会被上面的except块捕捉

5.0  
错误: 不能除以零 - division by zero  
None

# 定义一个简单的列表  
numbers = [1, 2, 3, 4, 5]  
  
# 获取列表的迭代器  
iterator = iter(numbers)  
  
# 初始化一个变量来存储当前迭代的元素  
current_number = None  
  
# 使用while循环手动迭代  
while True:  
    try:  
        # 尝试获取迭代器的下一个元素  
        current_number = next(iterator)  
        # 打印当前元素  
        print(current_number)  
    except StopIteration:  
        # 捕捉StopIteration异常，表示迭代结束  
        print("迭代已完成，没有更多元素。")  
        # 退出循环  
        break  
    # 可以在这里添加其他处理当前元素的逻辑  
  
# 注意：在实际编程中，上面的代码可以简化为一个for循环  
# for number in numbers:  
#     print(number)

1  
2  
3  
4  
5  
迭代已完成，没有更多元素。

# 定义一个简单的生成器函数  
def my_generator():  
    try:  
        # 生成一些数字  
        for i in range(5):  
            yield i  
        # 这里的代码在生成器正常结束时不会执行，因为yield会暂停函数执行  
    except GeneratorExit:  
        # 捕获GeneratorExit异常，执行清理操作  
        print("生成器被请求关闭，执行清理操作...")  
    finally:  
        # finally块中的代码无论是否发生异常都会执行  
        # 这里也可以执行一些清理操作，但通常用于释放资源等  
        print("生成器结束，执行finally块中的代码...")  
  
# 使用生成器  
gen = my_generator()  
  
# 迭代生成器的前三个元素  
for _ in range(3):  
    print(next(gen))  
  
# 关闭生成器  
gen.close()  
  
# 注意：下面的代码不会执行，因为生成器已经被关闭  
# print(next(gen))  # 这将引发一个StopIteration异常，但因为生成器已关闭，不会执行到这里

0  
1  
2  
生成器被请求关闭，执行清理操作...  
生成器结束，执行finally块中的代码...

# 注意：这是Python 2风格的代码，Python 3中不存在StandardError  
  
# 导入StandardError（实际上在Python 3中这是不可能的，因为StandardError不存在）  
# from exceptions import StandardError  # 在Python 2中可能需要这样导入，但在Python 3中无效  
  
# 由于StandardError在Python 3中不存在，我们假设这是Python 2环境，  
# 并且直接捕获Exception来模拟（因为Exception在Python 2和3中都存在，并且是StandardError的父类）  
try:  
    # 尝试执行一些可能会引发异常的代码  
    result = 10 / 0  # 这将引发ZeroDivisionError，它是StandardError的子类（在Python 2中）  
except StandardError as e:  # 在Python 3中，应使用Exception  
    # 捕获StandardError（或任何它的子类异常）  
    print("捕获到StandardError异常:", e)  
else:  
    # 如果没有异常发生，执行这部分代码  
    print("没有异常发生，结果是:", result)  
finally:  
    # 无论是否发生异常，都会执行这部分代码  
    print("执行finally块中的代码")

try:  
    # 尝试执行一些可能会引发异常的代码  
    result = 10 / 0  # 这将引发ZeroDivisionError，它是Exception的子类  
except Exception as e:  # 捕获所有内置异常  
    # 捕获Exception（或任何它的子类异常）  
    print("捕获到Exception异常:", e)  
else:  
    # 如果没有异常发生，执行这部分代码  
    print("没有异常发生，结果是:", result)  
finally:  
    # 无论是否发生异常，都会执行这部分代码  
    print("执行finally块中的代码")

捕获到Exception异常: division by zero  
执行finally块中的代码

# 定义一个函数，它尝试执行除法运算  
def divide_numbers(a, b):  
    try:  
        # 尝试将两个数相除  
        result = a / b  
    except ZeroDivisionError as e:  # 捕获除以零的异常  
        # 如果捕获到除以零的异常，打印错误信息  
        print("捕获到ZeroDivisionError异常: 不能除以零!")  
        # 可以选择返回一个特殊值，或者重新引发异常等  
        # 这里我们简单地返回None  
        return None  
    except ArithmeticError as e:  # 这个except块在当前的上下文中是多余的，  
                                  # 因为没有直接引发ArithmeticError的代码  
        # 如果捕获到ArithmeticError（或其子类）的异常，打印错误信息  
        # 注意：在这个例子中，这个except块永远不会被执行到，  
        # 因为ZeroDivisionError已经被上面的except块捕获了，  
        # 而且我们没有做会引发其他ArithmeticError子类异常的操作  
        print("捕获到ArithmeticError异常: 一个算术错误发生了!")  
    else:  
        # 如果没有异常发生，返回除法运算的结果  
        return result  
    finally:  
        # 无论是否发生异常，都会执行这部分代码  
        print("执行finally块中的代码")  
  
# 测试函数  
print(divide_numbers(10, 2))  # 应该正常输出5.0，并打印finally块中的信息  
print(divide_numbers(10, 0))  # 应该捕获到ZeroDivisionError，并打印相应的信息  
# 下面的代码不会引发ArithmeticError（除了已经被捕获的ZeroDivisionError之外），  
# 所以第二个except块永远不会被执行到  
# 为了演示目的，我们可以注释掉第一个except块来查看效果（但在这里不做这个操作）

5.0  
执行finally块中的代码  
捕获到ZeroDivisionError异常: 不能除以零!  
执行finally块中的代码

# 定义一个函数，它尝试执行一些可能导致FloatingPointError的浮点运算  
# 注意：在标准的Python环境中，下面的代码不会实际引发FloatingPointError  
def risky_float_operation(value):  
    try:  
        # 假设这里有一些复杂的浮点运算，可能会引发FloatingPointError  
        # 但由于Python的浮点运算通常很健壮，所以这里我们不会真的引发它  
        # 为了模拟，我们可以人为地引发一个FloatingPointError（但这在实际代码中是不推荐的）  
        # raise FloatingPointError("这是一个模拟的FloatingPointError异常")  
          
        # 实际上，我们做一些无害的浮点运算  
        result = value * 0.0  # 这将总是返回0.0，但不会引发异常  
          
        # 为了进一步模拟，我们可以检查value是否为某种“特殊”的浮点值，  
        # 但即使这样，我们也不会直接引发FloatingPointError。  
        # 相反，我们可以抛出一个自定义的异常来模拟这种情况。  
        if isinstance(value, float) and (value != value):  # 检查NaN（不是一个数字）  
            raise FloatingPointError("模拟检测到一个非法的浮点值（NaN）")  
          
        return result  
    except FloatingPointError as e:  
        # 捕获FloatingPointError异常（如果它真的被引发了的话）  
        print("捕获到FloatingPointError异常:", e)  
        # 在实际应用中，可能需要进行一些错误处理或恢复操作  
        return None  # 或者返回一个错误码、抛出另一个异常等  
    finally:  
        # 无论是否发生异常，都会执行这部分代码  
        print("执行finally块中的代码")  
  
# 测试函数  
# 使用一个普通的浮点数进行测试  
print(risky_float_operation(10.5))  # 应该正常输出0.0，并打印finally块中的信息  
  
# 使用一个特殊的浮点值NaN进行测试（需要手动创建NaN）  
import math  
nan_value = float('nan')  # 创建一个NaN值  
print(risky_float_operation(nan_value))  # 应该捕获到自定义的FloatingPointError异常（模拟的）

0.0  
执行finally块中的代码  
捕获到FloatingPointError异常: 这是一个模拟的FloatingPointError异常  
执行finally块中的代码  
None

0.0  
执行finally块中的代码  
捕获到FloatingPointError异常: 模拟检测到一个非法的浮点值（NaN）  
执行finally块中的代码  
None

# 导入sys模块，用于获取Python解释器限制的信息  
import sys  
  
# 打印Python解释器对整数大小的最大限制（以字节为单位）  
print("Python解释器对整数大小的最大限制（字节为单位）:", sys.getsizeof(sys.maxsize))  
  
# 打印Python解释器对整数大小的最大限制（实际值）  
print("Python解释器对整数大小的最大限制（实际值）:", sys.maxsize)  
  
# 尝试计算一个非常大的整数的平方  
# 这里使用sys.maxsize * 2是为了确保结果超出了Python解释器能够处理的整数范围  
# 注意：实际触发OverflowError的数值可能因Python版本或平台而异  
try:  
    # 计算一个非常大的整数的平方  
    result = (sys.maxsize * 2) ** 2  # 这行代码尝试计算一个非常大的数，超出了Python解释器的整数表示范围  
    print("计算结果:", result)  # 如果上面的计算没有触发异常，这行代码将打印结果  
except OverflowError as e:  
    # 如果触发了OverflowError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 OverflowError 异常:", e)

Python解释器对整数大小的最大限制（字节为单位）: 24  
Python解释器对整数大小的最大限制（实际值）: 9223372036854775807  
捕获到 OverflowError 异常: (32-bit signed integer overflow detected)  # 或类似的错误信息，具体取决于Python版本和平台

# 定义一个变量，其值为0  
divisor = 0  
  
# 尝试进行除法运算  
# 这里我们试图将10除以divisor，但由于divisor的值为0，这将触发ZeroDivisionError异常  
try:  
    # 进行除法运算  
    result = 10 / divisor  # 这行代码尝试将10除以0，这会触发ZeroDivisionError异常  
    print("计算结果:", result)  # 如果上面的计算没有触发异常，这行代码将打印结果  
except ZeroDivisionError as e:  
    # 如果触发了ZeroDivisionError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 ZeroDivisionError 异常:", e)

捕获到 ZeroDivisionError 异常: division by zero

# 定义一个变量，其值不等于预期的值  
value = 5  
  
# 使用断言来检查变量的值是否等于10  
# 如果value的值不等于10，这将触发AssertionError异常  
try:  
    # 断言value的值等于10  
    assert value == 10, "value应该等于10，但实际上是{}".format(value)  # 如果value不等于10，这将触发AssertionError，并显示错误消息  
    print("断言通过，value的值是10")  # 如果上面的断言没有触发异常，这行代码将打印消息  
except AssertionError as e:  
    # 如果触发了AssertionError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 AssertionError 异常:", e)

捕获到 AssertionError 异常: value应该等于10，但实际上是5

# 定义一个简单的类  
class MyClass:  
    def __init__(self, name):  
         = name  # 初始化一个名为name的属性  
  
# 创建一个MyClass的实例  
my_object = MyClass("TestObject")  
  
# 尝试访问一个存在的属性  
print("存在的属性name的值:", my_)  # 这将正确打印出name属性的值  
  
# 尝试访问一个不存在的属性  
try:  
    # 尝试访问不存在的属性age  
    print("不存在的属性age的值:", my_object.age)  # 这将触发AttributeError异常，因为age属性不存在  
except AttributeError as e:  
    # 如果触发了AttributeError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 AttributeError 异常:", e)

存在的属性name的值: TestObject  
捕获到 AttributeError 异常: 'MyClass' object has no attribute 'age'

# 尝试从标准输入读取数据，直到遇到EOF  
try:  
    # 使用input()函数从标准输入读取一行数据  
    # input()函数会在用户按下Enter键后返回输入的数据  
    # 但如果用户直接表示输入结束（如Ctrl+D或Ctrl+Z+Enter），则会触发EOFError  
    while True:  
        user_input = input("请输入一些数据（按Ctrl+D或Ctrl+Z+Enter结束输入）：")  
        print("你输入了：", user_input)  
except EOFError:  
    # 如果触发了EOFError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 EOFError 异常：输入已结束。")

第一行数据  
第二行数据

请输入一些数据（按Ctrl+D或Ctrl+Z+Enter结束输入）：第一行数据  
你输入了： 第一行数据  
请输入一些数据（按Ctrl+D或Ctrl+Z+Enter结束输入）：第二行数据  
你输入了： 第二行数据  
捕获到 EOFError 异常：输入已结束。

# 尝试打开一个不存在的文件，并捕获可能发生的OSError异常  
try:  
    # 使用open()函数尝试打开一个名为'nonexistent_file.txt'的文件  
    # 模式'r'表示以只读模式打开文件  
    # 如果文件不存在，这将触发OSError异常  
    with open('nonexistent_file.txt', 'r') as file:  
        # 如果文件成功打开，这里将读取文件内容  
        # 但由于文件不存在，下面的代码将不会被执行  
        file_content = file.read()  
        print("文件内容：", file_content)  
except OSError as e:  
    # 如果触发了OSError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 OSError 异常：", e)

捕获到 OSError 异常： [Errno 2] No such file or directory: 'nonexistent_file.txt'

# Python 2 代码示例  
  
# 尝试打开一个不存在的文件，并捕获可能发生的IOError异常  
try:  
    # 使用open()函数尝试打开一个名为'nonexistent_file.txt'的文件  
    # 模式'r'表示以只读模式打开文件  
    # 如果文件不存在，这将触发IOError异常（在Python 3中是OSError）  
    file_handle = open('nonexistent_file.txt', 'r')  
      
    # 如果文件成功打开，这里将读取文件内容  
    # 但由于文件不存在，下面的代码将不会被执行  
    file_content = file_handle.read()  
    print("文件内容：", file_content)  
      
    # 关闭文件（在Python 2中，通常需要在finally块中关闭文件，但这里为了简化省略了）  
    # 注意：在Python 3中，使用with语句可以自动管理文件的打开和关闭  
    file_handle.close()  
      
except IOError as e:  
    # 如果触发了IOError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 IOError 异常：", e)

# Python 3 代码示例  
  
# 尝试打开一个不存在的文件，并捕获可能发生的OSError异常  
try:  
    # 使用with语句和open()函数尝试打开一个名为'nonexistent_file.txt'的文件  
    # 模式'r'表示以只读模式打开文件  
    # 如果文件不存在，这将触发OSError异常  
    with open('nonexistent_file.txt', 'r') as file_handle:  
        # 如果文件成功打开，这里将读取文件内容  
        # 但由于文件不存在，下面的代码将不会被执行  
        file_content = file_handle.read()  
        print("文件内容：", file_content)  
          
except OSError as e:  
    # 如果触发了OSError异常，这行代码将捕获异常并打印错误信息  
    print("捕获到 OSError 异常：", e)

捕获到 OSError 异常： [Errno 2] No such file or directory: 'nonexistent_file.txt'

# Python 3 代码示例，用于演示 OSError 异常的处理  
  
# 尝试打开一个不存在的文件，并捕获可能发生的 OSError 异常  
try:  
    # 使用 with 语句和 open() 函数尝试以只读模式打开一个名为 'nonexistent_file.txt' 的文件  
    # with 语句确保文件在使用后会被正确关闭，即使在读取文件时发生异常也是如此  
    with open('nonexistent_file.txt', 'r') as file_handle:  
        # 如果文件成功打开，这里将读取文件内容并打印出来  
        # 但由于文件不存在，下面的代码将不会被执行  
        file_content = file_handle.read()  
        print("文件内容：", file_content)  
          
# 注意：在Python中，当 try 块后面没有 else 块时，不需要额外的缩进级别来结束 try 块  
# try 块在逻辑上直接结束于下面的 except 块之前（这里由于格式问题，看起来像是有一个缩进，实际上不应该有）  
  
except OSError as e:  
    # 如果在尝试打开或读取文件时触发了 OSError 异常，这行代码将捕获异常并打印错误信息  
    # e 是捕获到的 OSError 异常对象，它包含了错误的详细信息  
    print("捕获到 OSError 异常：", e)

捕获到 OSError 异常： [Errno 2] No such file or directory: 'nonexistent_file.txt'

# 假设性的Python 2代码示例（或早期Python 3版本），用于演示WindowsError异常的处理  
# 注意：在Python 3.3及更高版本中，应捕获OSError而不是WindowsError  
  
import os  
  
# 尝试执行一个可能会引发WindowsError的操作  
# 例如，尝试访问一个受保护的Windows系统文件或目录  
try:  
    # 假设'C:\\Windows\\System32\\config\\system'是一个受保护的文件路径  
    # 注意：在实际代码中，尝试访问这样的路径可能会导致程序崩溃或系统不稳定  
    # 这里仅作为示例，不要在生产环境中运行这样的代码  
    protected_file_path = r'C:\Windows\System32\config\system'  
      
    # 使用os.open()尝试打开受保护的文件  
    # 注意：在实际应用中，应使用更安全的文件操作方法，如open()与with语句  
    # os.open()返回一个文件描述符，需要在使用完毕后通过os.close()关闭  
    file_descriptor = os.open(protected_file_path, os.O_RDONLY)  
      
    # 如果文件成功打开，这里将读取文件内容（但在这个例子中，我们不会真的这样做）  
    # 由于文件是受保护的，下面的代码实际上不会被执行  
    # file_content = os.read(file_descriptor, 1024)  # 读取前1024个字节作为示例  
      
    # 注意：在这个例子中，我们故意省略了关闭文件描述符的代码  
    # 在实际应用中，应该在finally块中或使用with语句来确保文件被正确关闭  
    # 但由于我们是为了演示WindowsError，所以这里省略了这些步骤  
      
except WindowsError as e:  
    # 如果在尝试打开受保护的文件时触发了WindowsError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到 WindowsError 异常：", e)  
  
# 注意：在实际代码中，如果打开了文件描述符，则应该在finally块中关闭它  
# 但由于我们是为了演示异常处理，所以这里省略了关闭文件描述符的步骤

# Python代码示例，用于演示ImportError异常的处理  
  
# 尝试导入一个不存在的模块，并捕获可能发生的ImportError异常  
try:  
    # 尝试导入一个名为'nonexistent_module'的模块  
    # 由于这个模块不存在，Python解释器将引发ImportError异常  
    import nonexistent_module  
      
    # 如果模块成功导入，这里的代码将会执行  
    # 但由于模块不存在，下面的代码将不会被执行  
    print("成功导入nonexistent_module模块")  
      
except ImportError as e:  
    # 如果在尝试导入模块时触发了ImportError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到ImportError异常：", e)  
  
# 预期的运行结果：  
# 捕获到ImportError异常： No module named 'nonexistent_module'  
# 或者在Python 3.6+中可能是：  
# 捕获到ImportError异常： cannot import name 'nonexistent_module'  
# 注意：具体的错误信息可能会因Python版本和安装环境的不同而略有差异

捕获到ImportError异常： No module named 'nonexistent_module'

捕获到ImportError异常： cannot import name 'nonexistent_module'

# Python代码示例，用于演示LookupError及其子类KeyError和IndexError的处理  
  
# 尝试访问字典中不存在的键，并捕获KeyError异常  
try:  
    # 创建一个字典  
    my_dict = {'name': 'Alice', 'age': 30}  
      
    # 尝试获取字典中不存在的键'address'的值  
    # 这将引发KeyError异常  
    address = my_dict['address']  
      
except KeyError as e:  
    # 捕获KeyError异常并打印错误信息  
    print("捕获到KeyError异常：", e)  
  
# 尝试访问列表的索引超出范围的元素，并捕获IndexError异常  
try:  
    # 创建一个列表  
    my_list = [1, 2, 3]  
      
    # 尝试访问列表的第四个元素（索引3），但列表只有三个元素（索引0, 1, 2）  
    # 这将引发IndexError异常  
    fourth_element = my_list[3]  
      
except IndexError as e:  
    # 捕获IndexError异常并打印错误信息  
    print("捕获到IndexError异常：", e)  
  
# 注意：虽然LookupError是KeyError和IndexError的基类，但在实际开发中  
# 我们通常直接捕获具体的异常（如KeyError或IndexError），而不是捕获更一般的LookupError  
# 因为捕获更具体的异常可以提供更明确的错误处理逻辑  
  
# 预期的运行结果：  
# 捕获到KeyError异常： 'address'  
# 捕获到IndexError异常： list index out of range