有史以来最全的异常类讲解没有之一！第二部分爆肝2万字，终于把Python的异常类写完了！最全Python异常类合集和案例演示，第二部分

本文是第二部分，第一部分请看：
有史以来最全的异常类讲解没有之一！爆肝3万字，终于把Python的异常类写完了！最全Python异常类合集和案例演示，第一部分

• 博客主页：长风清留扬-CSDN博客
• 系列专栏：Python基础专栏
• 每天更新大数据相关方面的技术，分享自己的实战工作经验和学习总结，尽量帮助大家解决更多问题和学习更多新知识，欢迎评论区分享自己的看法
• 感谢大家点赞收藏⭐评论

异常类型

IndexError

IndexError 是 Python 中的一个标准异常类型，它会在你尝试访问序列（如列表、元组、字符串等）的索引超出其有效范围时引发。这个异常表明你尝试访问的索引在序列中不存在。

案例

# Python代码示例，用于演示IndexError异常的处理  
  
# 创建一个包含三个元素的列表  
my_list = [10, 20, 30]  
  
# 尝试访问列表的第四个元素（索引为3），但列表只有三个元素（索引0, 1, 2）  
try:  
    # 这行代码将尝试获取列表my_list中索引为3的元素  
    # 由于索引3超出了列表的范围，Python将引发IndexError异常  
    fourth_element = my_list[3]  
      
    # 如果上面的代码没有引发异常，这行代码将打印出第四个元素的值  
    # 但由于索引超出范围，这行代码将不会被执行  
    print("第四个元素的值是：", fourth_element)  
      
except IndexError as e:  
    # 如果在尝试访问列表元素时触发了IndexError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到IndexError异常：", e)  
  
# 预期的运行结果：  
# 捕获到IndexError异常： list index out of range

• my_list = [10, 20, 30]：创建一个包含三个整数元素的列表 my_list。
• try:：开始一个 try 块，用于尝试执行可能引发异常的代码。
• fourth_element = my_list[3]：尝试获取列表 my_list 中索引为 3 的元素。由于索引超出范围，这将引发 IndexError 异常。
• print(“第四个元素的值是：”, fourth_element)：如果上面的代码没有引发异常，这行代码将打印出第四个元素的值。但由于索引超出范围，这行代码将不会被执行。
• except IndexError as e:：如果 try 块中的代码触发了 IndexError 异常，这行代码将捕获该异常，并将其异常对象赋值给变量 e。
• print(“捕获到IndexError异常：”, e)：打印捕获到的 IndexError 异常的信息，包括具体的错误消息 “list index out of range”。

在实际开发中，当处理列表、元组、字符串等序列类型时，应该始终注意索引的有效性，以避免引发 IndexError 异常。如果可能的话，可以使用条件语句来检查索引是否在有效范围内，或者使用异常处理来捕获并处理 IndexError 异常。

运行结果

当运行上述代码时，Python 解释器会尝试执行 try 块中的代码。在尝试访问 my_list[3] 时，由于 my_list 列表只有三个元素（索引为 0, 1, 2），索引 3 超出了列表的有效范围。因此，Python 解释器会引发 IndexError 异常。

由于 IndexError 异常被 except IndexError as e: 块捕获，程序将不会崩溃，而是打印出错误信息 “捕获到IndexError异常： list index out of range”。

KeyError

KeyError 是 Python 中的一个标准异常类型，它会在你尝试访问字典中不存在的键时引发。这个异常表明你尝试获取的键在字典的键集合中不存在。

案例

# Python代码示例，用于演示KeyError异常的处理  
  
# 创建一个包含两个键值对的字典  
my_dict = {'name': 'Alice', 'age': 30}  
  
# 尝试访问字典中不存在的键'address'  
try:  
    # 这行代码将尝试获取字典my_dict中键为'address'的值  
    # 由于字典中没有键为'address'的项，Python将引发KeyError异常  
    address = my_dict['address']  
      
    # 如果上面的代码没有引发异常，这行代码将打印出地址的值  
    # 但由于键不存在，这行代码将不会被执行  
    print("地址是：", address)  
      
except KeyError as e:  
    # 如果在尝试访问字典项时触发了KeyError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到KeyError异常：", e)  
  
# 预期的运行结果：  
# 捕获到KeyError异常： 'address'

• my_dict = {‘name’: ‘Alice’, ‘age’: 30}：创建一个包含两个键值对的字典 my_dict。
• try:：开始一个 try 块，用于尝试执行可能引发异常的代码。
• address = my_dict[‘address’]：尝试获取字典 my_dict 中键为 ‘address’ 的值。由于键不存在，这将引发 KeyError 异常。
• print(“地址是：”, address)：如果上面的代码没有引发异常，这行代码将打印出地址的值。但由于键不存在，这行代码将不会被执行。
• except KeyError as e:：如果 try 块中的代码触发了 KeyError 异常，这行代码将捕获该异常，并将其异常对象赋值给变量 e。这里的 e 将包含引发异常的键的信息。
• print(“捕获到KeyError异常：”, e)：打印捕获到的 KeyError 异常的信息，包括具体的键 ‘address’。

在实际开发中，当处理字典时，应该始终注意键的存在性，以避免引发 KeyError 异常。如果可能的话，可以使用 dict.get(key, default=None) 方法来访问字典项，该方法在键不存在时会返回 default 值（默认为 None），而不是引发异常。另外，也可以使用 in 关键字来检查键是否存在于字典中。

运行结果

当运行上述代码时，Python 解释器会尝试执行 try 块中的代码。在尝试访问 my_dict[‘address’] 时，由于 my_dict 字典中没有键为 ‘address’ 的项，Python 解释器会引发 KeyError 异常。

由于 KeyError 异常被 except KeyError as e: 块捕获，程序将不会崩溃，而是打印出错误信息 “捕获到KeyError异常： ‘address’”。这里的 ‘address’ 是引发异常的键。

MemoryError

MemoryError 是 Python 中的一个标准异常类型，它会在 Python 解释器无法为对象分配足够的内存时引发。这种异常通常发生在尝试创建非常大的数据结构，或者系统内存不足时。

由于 MemoryError 异常通常与系统的物理内存限制有关，因此很难通过简单的代码示例来准确模拟。不过，我可以提供一个尝试分配大量内存的代码示例，并解释其可能的行为和预期的结果（尽管实际结果可能因系统配置而异）。

案例(运行请注意)

请注意，运行下面的代码可能会导致你的 Python 解释器或整个系统变得非常缓慢，甚至崩溃。因此，请在虚拟机、可控环境或你有权限恢复的系统上运行此代码。

# Python代码示例，用于尝试引发MemoryError异常  
  
# 尝试创建一个非常大的列表，以触发MemoryError（此代码可能因系统而异）  
try:  
    # 创建一个空列表  
    large_list = []  
      
    # 尝试向列表中添加大量的整数，直到内存不足  
    # 注意：这个循环可能会非常慢，甚至导致系统崩溃，因此请谨慎运行  
    for i in range(10**10):  # 尝试添加10^10个整数（这是一个非常大的数）  
        # 将整数i添加到列表中  
        # 随着列表的增长，它将占用越来越多的内存  
        large_list.append(i)  
          
    # 如果上面的代码没有引发异常，这行代码将打印出列表的长度  
    # 但由于内存限制，这行代码很可能不会被执行  
    print("列表长度是：", len(large_list))  
      
except MemoryError as e:  
    # 如果在尝试分配内存时触发了MemoryError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到MemoryError异常：系统内存不足")  
  
# 注意：由于系统内存限制和Python解释器的内存管理策略  
# 这段代码可能不会立即引发MemoryError，而是使系统变得非常缓慢  
# 或者在某些情况下，操作系统可能会杀死Python进程以防止系统崩溃  
# 因此，运行这段代码时要格外小心

• 代码尝试创建一个非常大的列表，并向其中添加大量的整数。
• 随着列表的增长，它将占用越来越多的内存。
• 当系统内存不足，无法为更多对象分配内存时，Python 解释器将引发MemoryError 异常。
• except MemoryError as e: 块将捕获该异常，并打印出错误信息 “捕获到MemoryError异常：系统内存不足”。
• 然而，由于系统内存限制和 Python 解释器的内存管理策略，这段代码可能不会立即引发 MemoryError。相反，它可能会使系统变得非常缓慢，或者在某些情况下，操作系统可能会采取措施（如杀死 Python 进程）来防止系统崩溃。

运行结果

由于实际运行结果取决于你的系统配置和 Python 解释器的实现，所以结果是不固定的，下面是预期会产生的几种运行情况
预期运行结果：

• 代码运行得非常慢，因为列表正在不断增长并占用大量内存。
• 在某个点，MemoryError 异常被引发，并且错误信息被打印出来。
• 操作系统采取措施杀死 Python 进程，以防止系统崩溃。
• 如果系统有足够的内存来处理这个请求（这在大多数现代计算机上对于 10**10 个整数来说是不太可能的），代码可能会成功运行并打印出列表的长度，但这将导致极大的内存使用。

因此，请谨慎运行这段代码，并确保在可控环境中执行，以避免对系统造成不可恢复的损害。

NameError

NameError 是 Python 中的一个标准异常类型，它会在你尝试访问一个未定义或未声明的变量名时引发。这种异常通常发生在以下几种情况：

• 使用了未赋值的变量。
• 变量名拼写错误。
• 变量在当前作用域中不可见（例如，在函数外部尝试访问函数内部定义的局部变量）。

案例

# Python代码示例，用于演示NameError异常的处理  
  
# 尝试访问一个未定义的变量  
try:  
    # 这行代码将尝试打印一个名为undefined_variable的变量的值  
    # 但由于该变量从未被定义，Python将引发NameError异常  
    print("未定义的变量值是：", undefined_variable)  
      
except NameError as e:  
    # 如果在尝试访问未定义的变量时触发了NameError异常  
    # 这行代码将捕获异常并打印错误信息  
    print("捕获到NameError异常：", e)  
  
# 定义一个变量并尝试访问它（这部分代码不会引发异常）  
defined_variable = "这是一个已定义的变量"  
print("已定义的变量值是：", defined_variable)  
  
# 预期的运行结果：  
# 捕获到NameError异常： name 'undefined_variable' is not defined  
# 已定义的变量值是： 这是一个已定义的变量

• try:：开始一个 try 块，用于尝试执行可能引发异常的代码。
• print(“未定义的变量值是：”, undefined_variable)：尝试打印一个未定义的变量 undefined_variable 的值。由于该变量未定义，这将引发 NameError 异常。
• except NameError as e:：如果 try 块中的代码触发了 NameError 异常，这行代码将捕获该异常，并将其异常对象赋值给变量 e。
• print(“捕获到NameError异常：”, e)：打印捕获到的 NameError 异常的信息，包括具体的变量名 ‘undefined_variable’。
• defined_variable = “这是一个已定义的变量”：定义一个名为 defined_variable 的变量，并赋值为一个字符串。
• print(“已定义的变量值是：”, defined_variable)：打印已定义的变量 defined_variable 的值。

运行结果

当运行上述代码时，Python 解释器会尝试执行 try 块中的代码。在尝试打印 undefined_variable 的值时，由于该变量从未被定义，Python 解释器会引发 NameError 异常。

由于 NameError 异常被 except NameError as e: 块捕获，程序将不会崩溃，而是打印出错误信息 “捕获到NameError异常： name ‘undefined_variable’ is not defined”。这里的 ‘undefined_variable’ 是引发异常的变量名。

接下来，代码定义了一个名为 defined_variable 的变量，并成功打印了其值，这部分代码没有引发任何异常。

UnboundLocalError

UnboundLocalError 是 Python 中的一个异常类型，它会在你尝试访问一个局部变量，但该变量在当前作用域内已经被声明（通常是通过赋值语句），但在使用它之前尚未被绑定（即尚未被赋予一个值）时引发。这种异常通常发生在函数内部，当你尝试在变量赋值之前就使用它时。

案例

# 修改后的Python代码示例，更准确地演示UnboundLocalError异常  
  
def my_function():  
    # 尝试打印局部变量，但在打印之前尚未声明和赋值  
    # 这将直接引发UnboundLocalError异常，因为变量尚未被绑定  
    try:  
        print("局部变量的值是：", local_variable)  # 这行代码将引发异常  
    except UnboundLocalError as e:  
        # 捕获异常并打印错误信息  
        print("捕获到UnboundLocalError异常：", e)  
      
    # 现在声明并赋值局部变量  
    local_variable = "这是一个已赋值的局部变量"  
    print("局部变量赋值后的值是：", local_variable)  
  
# 调用函数  
my_function()  
  
# 预期的运行结果：  
# 捕获到UnboundLocalError异常： local variable 'local_variable' referenced before assignment  
# 局部变量赋值后的值是： 这是一个已赋值的局部变量

运行结果

当运行修改后的代码时，my_function 函数中的 try 块会尝试打印 local_variable 的值。但是，由于 local_variable 在打印之前尚未被声明和赋值，Python 解释器会引发 UnboundLocalError 异常。

异常被 except UnboundLocalError as e: 块捕获，程序将打印出错误信息 “捕获到UnboundLocalError异常： local variable ‘local_variable’ referenced before assignment”。这里的 ‘local_variable’ 是引发异常的变量名。

接下来，代码为 local_variable 赋值，并成功打印了其值。由于异常已经被捕获并处理，赋值和打印操作将正常执行。

在实际开发中，当遇到 UnboundLocalError 异常时，你应该检查变量是否在使用之前已经被正确声明和赋值。在函数内部，确保在引用变量之前已经为其赋予了一个值。

RuntimeError

在 Python 中，RuntimeError 是一个通用异常类型，用于指示解释器在运行时遇到的错误，但这些错误不属于其他更具体的异常类型（如 IndexError、KeyError、TypeError 等）。RuntimeError 通常表示程序中有一些逻辑错误或状态不一致，这些错误在程序执行期间被检测到。

案例

由于 RuntimeError 是一个通用异常，它可以由多种不同的操作或情况引发。以下是一个简单的例子，其中我们故意制造了一个可能导致 RuntimeError 的情况

# Python代码示例，展示可能引发RuntimeError的情况  
  
def recursive_function(n):  
    """  
    一个递归函数，它应该有一个停止条件来避免无限递归。  
    在这个例子中，我们故意遗漏了停止条件，以演示可能引发的RuntimeError（通常是RecursionError，它是RuntimeError的一个子类）。  
      
    参数:  
    n (int): 递归的深度。  
    """  
    # 递归调用自身，但没有检查停止条件  
    print(f"Recursion depth: {n}")  
    recursive_function(n + 1)  
  
# 调用递归函数，初始深度为0  
try:  
    # 这将尝试无限递归，直到达到Python解释器的递归限制  
    recursive_function(0)  
except RuntimeError as e:  
    # 在Python 3.5及更高版本中，更具体的RecursionError可能会被抛出  
    # 但由于RuntimeError是RecursionError的基类，这个except块仍然会捕获它  
    print(f"Caught a RuntimeError (or subclass): {e}")  
  
# 注意：在Python的实际运行中，上面的代码更可能抛出一个RecursionError，  
# 它是RuntimeError的一个特定子类，用于指示递归深度过大。  
# 递归错误通常包含一个关于“超过最大递归深度”的消息。  
# 由于递归深度限制是解释器的一个配置参数，因此具体的递归次数可能因Python版本和配置而异。  
  
# 预期的运行结果（取决于Python解释器的递归深度限制）：  
# 递归深度的打印输出，直到达到限制。  
# 然后捕获到RecursionError（作为RuntimeError的子类），并打印出错误信息，  
# 例如：“Caught a RuntimeError (or subclass): maximum recursion depth exceeded in comparison”

重要说明：

• 在上面的代码中，我提到了 RecursionError，它是 RuntimeError 的一个子类，专门用于指示递归深度过大。从 Python 3.5 开始，当递归深度超过解释器的限制时，通常会抛出 RecursionError 而不是 RuntimeError。但是，由于 RecursionError 继承自 RuntimeError，因此使用 except RuntimeError 仍然可以捕获它。
• 在实际开发中，你应该尽可能避免无限递归，并通过添加适当的停止条件来确保递归函数能够正确终止。
• 由于递归深度限制是解释器的一个配置参数（可以通过 sys.setrecursionlimit() 函数设置），因此上面的代码在不同的 Python 环境或配置中可能会有不同的行为。特别是，如果递归深度限制设置得非常高，代码可能会运行很长时间或消耗大量内存，而不是立即抛出异常。

（取决于递归深度限制）：

Recursion depth: 0  
Recursion depth: 1  
...  
Recursion depth: 997  # 具体的递归深度取决于解释器的限制  
Recursion depth: 998  
Recursion depth: 999  
Caught a RuntimeError (or subclass): maximum recursion depth exceeded in comparison

NotImplementedError

• 在 Python 中，NotImplementedError 异常是一个内置异常类型，用于指示某个操作或方法尚未实现。这通常发生在抽象基类（ABCs）中，当派生类没有覆盖基类中的抽象方法时，或者当某个方法应该根据条件执行不同的操作但尚未编写这些操作时。

• NotImplementedError 异常是告诉调用者：“这个功能或方法还没有被实现，所以你不能使用它。” 它是一个信号，表明代码还不完整，或者某个功能还在开发中。

案例

from abc import ABC, abstractmethod  
  
# 定义一个抽象基类，它有一个抽象方法  
class Shape(ABC):  
    @abstractmethod  
    def area(self):  
        """  
        计算形状的面积。  
          
        这个方法是一个抽象方法，意味着任何继承自Shape的类都必须实现它。  
        在这个例子中，我们没有在Shape类中实现它，所以它会抛出NotImplementedError。  
        """  
        raise NotImplementedError("Subclasses must implement this method!")  
  
# 定义一个圆形类，它继承自Shape类  
class Circle(Shape):  
    def __init__(self, radius):  
        self.radius = radius  
  
    # 实现area方法  
    def area(self):  
        """  
        计算圆形的面积。  
          
        这个方法是Shape类中抽象方法area的具体实现。  
        """  
        return 3.14159 * self.radius ** 2  
  
# 定义一个未实现area方法的矩形类（用于演示NotImplementedError）  
class Rectangle(Shape):  
    def __init__(self, width, height):  
        self.width = width  
        self.height = height  
  
    # 注意：这里没有实现area方法，所以它会继承Shape中的抽象方法，并抛出NotImplementedError。  
  
# 创建一个Circle实例并计算面积  
circle = Circle(5)  
print("Circle area:", circle.area())  # 输出：Circle area: 78.53975  
  
# 创建一个Rectangle实例（这将用于演示NotImplementedError）  
rectangle = Rectangle(4, 6)  
  
try:  
    # 尝试计算矩形的面积，但由于Rectangle类没有实现area方法，所以会抛出NotImplementedError。  
    print("Rectangle area:", rectangle.area())  
except NotImplementedError as e:  
    # 捕获NotImplementedError并打印错误消息  
    print("Caught NotImplementedError:", e)  
  
# 预期的运行结果：  
# Circle area: 78.53975  
# Caught NotImplementedError: Subclasses must implement this method!

运行结果

• Shape 类是一个抽象基类，它定义了一个抽象方法 area()。这个方法没有具体的实现，只是抛出了一个 NotImplementedError 异常。
• Circle 类继承自 Shape 类，并提供了 area() 方法的具体实现，用于计算圆形的面积。
• Rectangle 类也继承自 Shape 类，但它没有提供 area() 方法的具体实现。- 因此，当尝试调用 rectangle.area() 时，会继承 Shape 类中的抽象方法，并抛出 NotImplementedError 异常。
• 创建一个 Circle 实例并调用其 area() 方法，成功计算出圆形的面积并打印出来。
• 创建一个 Rectangle 实例并尝试调用其 area() 方法，由于该方法未实现，因此抛出了 NotImplementedError 异常。这个异常被 try-except 块捕获，并打印出错误消息。

SyntaxError

• 在 Python 中，SyntaxError 异常是一个内置异常类型，用于指示代码中存在语法错误。当 Python 解释器尝试执行代码时，如果它发现代码不符合 Python 的语法规则，就会抛出 SyntaxError 异常。这通常发生在代码编写阶段，是告诉开发者代码中有错误需要修正。

• SyntaxError 异常会包含有关错误位置的信息，例如错误发生的文件名、行号和列号，以及一个错误消息，该消息描述了导致错误的具体问题。

案例

# 这是一个包含语法错误的Python代码示例  
  
# 定义一个函数，但是忘记了在函数定义后加上冒号（:）  
def say_hello  
    # 由于上一行缺少冒号，这一行将被视为语法错误的一部分，尽管它本身没有语法错误  
    # 如果上一行有冒号，这里将打印 "Hello, world!"  
    print("Hello, world!")  
  
# 尝试运行上面的代码  
# 由于存在语法错误，Python 解释器将抛出 SyntaxError 异常  
# 下面的代码块不会被执行，因为解释器在遇到错误时会停止执行  
  
try:  
    # 这行代码尝试调用 say_hello 函数，但由于语法错误，它永远不会被执行  
    say_hello()  
except SyntaxError as e:  
    # 这个 except 块也不会捕获到 SyntaxError，因为 SyntaxError 是在代码编译时抛出的，  
    # 而不是在代码执行时。因此，这个 except 块实际上永远不会被执行。  
    # 在实际开发中，你通常不会在 try-except 块中捕获 SyntaxError。  
    # 相反，你会在代码编辑器或 IDE 中看到语法错误的提示，或者在运行脚本时看到解释器抛出的错误消息。  
    print("Caught a SyntaxError:", e)  
  
# 预期的运行结果：  
# 当尝试运行上面的脚本时，Python 解释器将抛出一个 SyntaxError 异常，并显示类似以下的错误消息：  
#   File "", line 2  
#     def say_hello  
#                    ^  
# SyntaxError: invalid syntax  
# 其中  是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 SyntaxError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要在编写代码时注意语法正确性，以避免此类错误。

重要说明：

• 在上面的代码中，def say_hello 后缺少了一个冒号（:），这是导致 SyntaxError 异常的原因。
• try-except 块无法捕获 SyntaxError，因为 SyntaxError 是在代码编译时抛出的，而不是在代码执行时。这意味着在代码尝试执行之前，解释器就已经发现了语法错误。
• 在实际开发中，你通常会在代码编辑器或集成开发环境（IDE）中看到语法错误的提示，这些工具会在你编写代码时实时检查语法。
• 如果在命令行或脚本中运行包含语法错误的代码，Python 解释器将显示一个错误消息，指出错误发生的位置和原因。

IndentationError

在 Python 中，IndentationError 异常是一个内置异常类型，它专门用于指出代码缩进错误。Python 是一种依赖缩进来定义代码块结构的语言，例如函数体、循环体和条件语句块等。如果缩进不正确，Python 解释器将无法正确解析代码的结构，从而引发 IndentationError。

案例

# 这是一个包含缩进错误的Python代码示例  
  
def greet(name):  
    # 这一行应该有一个缩进来表示它是函数体的一部分  
    # 但由于某种原因（例如复制粘贴时的误操作或编辑器设置问题），它没有被正确缩进  
print("Hello, " + name + "!")  
  
# 尝试调用上面的 greet 函数  
# 由于存在缩进错误，Python 解释器将抛出 IndentationError 异常  
# 下面的代码块不会被执行，因为解释器在遇到错误时会停止执行  
  
try:  
    # 这行代码尝试调用 greet 函数，但由于缩进错误，它永远不会被正确执行  
    greet("Alice")  
except IndentationError as e:  
    # 这个 except 块也不会捕获到 IndentationError，因为 IndentationError 是在代码编译时抛出的，  
    # 而不是在代码执行时。因此，这个 except 块实际上永远不会被执行。  
    # 在实际开发中，你通常不会在 try-except 块中捕获 IndentationError。  
    # 相反，你会在代码编辑器中看到缩进错误的提示，或者在运行脚本时看到解释器抛出的错误消息。  
    print("Caught an IndentationError:", e)  
  
# 预期的运行结果：  
# 当尝试运行上面的脚本时，Python 解释器将抛出一个 IndentationError 异常，并显示类似以下的错误消息：  
#   File "", line 3  
#     print("Hello, " + name + "!")  
#     ^  
# IndentationError: expected an indented block  
# 其中  是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 IndentationError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要确保代码的缩进是正确的，以避免此类错误。

重要说明：

• 在上面的代码中，print 语句应该被缩进以表示它是 greet 函数体的一部分。但是，由于缩进错误，它没有被正确缩进，这导致了 IndentationError 异常。
• try-except 块无法捕获 IndentationError，因为 IndentationError 是在代码编译时抛出的，而不是在代码执行时。这意味着在代码尝试执行之前，解释器就已经发现了缩进错误。
• 在实际开发中，你通常会在代码编辑器中看到缩进错误的提示，这些工具会在你编写代码时实时检查缩进。
• 如果在命令行或脚本中运行包含缩进错误的代码，Python 解释器将显示一个错误消息，指出错误发生的位置和原因。

TabError

在 Python 中，TabError 异常是一个内置异常类型，它专门用于指出在代码中使用了不一致的缩进方式。Python 允许使用空格或制表符（Tab）来进行缩进，但要求在同一个代码块中必须使用同一种方式。如果在同一个代码块中混用了空格和制表符进行缩进，Python 解释器将无法正确解析代码的结构，从而引发 TabError。

案例

# 这是一个包含TabError的Python代码示例  
  
def say_hello():  
	# 这一行使用了制表符（Tab）进行缩进  
	# 但在Python中，要求同一个代码块内的缩进方式必须一致  
	# 如果其他行使用了空格进行缩进，就会引发TabError  
    print("Hello, world!")  # 这一行使用了空格进行缩进，与上一行不一致  
  
# 尝试调用上面的 say_hello 函数  
# 由于存在缩进方式不一致的问题，Python 解释器将抛出 TabError 异常  
# 下面的代码块不会被执行，因为解释器在遇到错误时会停止执行  
  
try:  
    # 这行代码尝试调用 say_hello 函数，但由于缩进方式不一致，它永远不会被正确执行  
    say_hello()  
except TabError as e:  
    # 这个 except 块也不会捕获到 TabError，因为 TabError 是在代码编译时抛出的，  
    # 而不是在代码执行时。因此，这个 except 块实际上永远不会被执行。  
    # 在实际开发中，你通常不会在 try-except 块中捕获 TabError。  
    # 相反，你会在代码编辑器中看到缩进方式不一致的提示，  
    # 或者在运行脚本时看到解释器抛出的错误消息。  
    print("Caught a TabError:", e)  
  
# 预期的运行结果：  
# 当尝试运行上面的脚本时，Python 解释器将抛出一个 TabError 异常，并显示类似以下的错误消息：  
#   File "", line 4  
#     print("Hello, world!")  
#     ^  
# TabError: inconsistent use of tabs and spaces in indentation  
# 其中  是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 TabError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要确保代码的缩进方式是一致的，以避免此类错误。  
# 在编写代码时，建议要么全部使用空格进行缩进，要么全部使用制表符进行缩进，不要混用。

重要说明：

• 在上面的代码中，def say_hello(): 下的第一行使用了制表符（Tab）进行缩进，而 print(“Hello, world!”) 行则使用了空格进行缩进。这种不一致的缩进方式导致了 TabError 异常。
• try-except 块无法捕获 TabError，因为 TabError 是在代码编译时抛出的，而不是在代码执行时。这意味着在代码尝试执行之前，解释器就已经发现了缩进方式不一致的问题。
• 在实际开发中，你通常会在代码编辑器中看到缩进方式不一致的提示。大多数现代代码编辑器都提供了将制表符转换为空格或将空格转换为制表符的功能，以帮助你保持缩进方式的一致性。
• 如果在命令行或脚本中运行包含缩进方式不一致的代码，Python 解释器将显示一个错误消息，指出错误发生的位置和原因。

推荐阅读

Python基础

Python全网最全基础课程笔记(一)——基础入门
Python全网最全基础课程笔记(二)——变量
Python全网最全基础课程笔记(三)——所有运算符+运算符优先级
Python全网最全基础课程笔记(四)——基本数据类型
Python全网最全基础课程笔记(五)——选择结构+Python新特性Match
Python全网最全基础课程笔记(六)——循环结构
Python全网最全基础课程笔记(七)——列表，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(八)——字典，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(九)——集合，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十)——元组，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十一)——字符串所有操作，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十二)——函数，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十三)——作用域，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十四)——异常处理机制，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
有史以来最全的异常类讲解没有之一！爆肝3万字，终于把Python的异常类写完了！最全Python异常类合集和案例演示，第一部分

Python疑难杂症百科-BUG编年史

浮点数精度不再是困扰：Python高手的精准编程秘籍！解决Python浮点数精度问题！
还在为Python变量中遇到的BUG而发愁吗？，变量相关的问题和解决办法看这篇文章就够了！
还在为Python“运算符”中遇到的BUG而发愁吗？，变量相关的问题和解决办法看这篇文章就够了！

Python刷题面试宝典

Python列表实战题目练习，巩固知识、检查技术
Python “元组” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业
Python “字符串操作” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业
Python字典实战题目练习，巩固知识、检查技术
Python “集合” 100道实战题目练习，巩固知识、检查技术
Python “函数” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业
Python “异常处理机制” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业

Flink入门到就业

2024年最新Flink教程,从基础到就业，大家一起学习–基础篇
2024年最新Flink教程,从基础到就业，大家一起学习–入门篇
2024年最新Flink教程,从基础到就业，大家一起学习–Flink集群部署
2024年最新Flink教程,从基础到就业，大家一起学习–flink部署和集群部署(从本地测试到公司生产环境如何部署项目源码)
2024年最新Flink教程,从基础到就业，大家一起学习–Flink运行架构底层源码详解+实战
2024年最新Flink教程,从基础到就业，大家一起学习–Flink DataStream API-第一篇+源码讲解