# 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

# 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'

# 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代码示例，用于演示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  
# 已定义的变量值是： 这是一个已定义的变量

# 修改后的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  
# 局部变量赋值后的值是： 这是一个已赋值的局部变量

# 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”

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

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!

# 这是一个包含语法错误的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 "<filename>", line 2  
#     def say_hello  
#                    ^  
# SyntaxError: invalid syntax  
# 其中 <filename> 是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 SyntaxError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要在编写代码时注意语法正确性，以避免此类错误。

# 这是一个包含缩进错误的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 "<filename>", line 3  
#     print("Hello, " + name + "!")  
#     ^  
# IndentationError: expected an indented block  
# 其中 <filename> 是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 IndentationError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要确保代码的缩进是正确的，以避免此类错误。

# 这是一个包含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 "<filename>", line 4  
#     print("Hello, world!")  
#     ^  
# TabError: inconsistent use of tabs and spaces in indentation  
# 其中 <filename> 是你的脚本文件名，行号和列号指示了错误发生的确切位置。  
# 注意：由于 TabError 是在编译时抛出的，所以 try-except 块无法捕获它。  
# 你需要确保代码的缩进方式是一致的，以避免此类错误。  
# 在编写代码时，建议要么全部使用空格进行缩进，要么全部使用制表符进行缩进，不要混用。