长风清留扬

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

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

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

异常类型

SystemError

SystemError 是 Python 中一个较为底层的异常类型，通常表明解释器遇到了一个不应该发生的内部错误。这种错误通常是由 Python 解释器本身的问题或底层系统调用失败引起的。由于 SystemError 通常涉及到解释器或操作系统的深层次问题，所以这类错误通常不容易由用户代码直接引发，也很难由用户代码直接解决。

案例

下面的代码尝试通过修改 Python 的内部数据结构来模拟触发 SystemError 的场景。请注意，这种做法是非常危险和不推荐的，因为它可能导致 Python 解释器崩溃或行为异常。

# 导入sys模块，用于访问与Python解释器紧密相关的变量和函数  
import sys  
  
# 定义一个函数，用于修改Python的内部数据结构  
def trigger_system_error():  
    # 尝试获取sys模块中维护的模块列表的内部引用  
    # 注意：这种操作是非常危险的，因为它直接修改了Python解释器的内部状态  
    modules = sys.modules  
      
    # 打印修改前的模块列表长度  
    print(f"Before modification: {len(modules)} modules")  
      
    # 尝试通过不恰当的方式修改模块列表（例如，将其设置为None）  
    # 这种操作几乎肯定会触发SystemError，因为sys.modules是解释器内部的核心数据结构  
    try:  
        modules.clear()  # 尝试清空模块列表（实际上，直接清空sys.modules通常不会触发SystemError，但类似的不当操作可能）  
        # 下面的操作更加危险，它试图将sys.modules设置为None，这几乎肯定会触发错误  
        # 但由于这可能导致解释器立即崩溃，我们在实际执行时将其注释掉  
        # sys.modules = None  # 极度危险的操作，请勿在生产环境中尝试  
          
        # 为了模拟可能的SystemError场景，我们假设有一个底层操作失败并手动抛出SystemError  
        # 这仅用于教育目的，实际开发中不应这样做  
        raise SystemError("Simulated SystemError due to improper modification of sys.modules")  
      
    except SystemError as e:  
        # 捕获SystemError并打印错误信息  
        print(f"Caught SystemError: {e}")  
      
    # 由于前面的操作可能导致解释器状态不稳定，这里不再尝试打印修改后的模块列表长度  
    # print(f"After modification: {len(modules)} modules")  # 这行代码在实际运行时可能会被跳过或导致解释器异常  
  
# 调用函数以触发可能的SystemError  
trigger_system_error()

导入 sys 模块：
import sys：导入 sys 模块，以便访问与 Python 解释器紧密相关的变量和函数。
定义 trigger_system_error 函数：
这个函数尝试通过修改 Python 的内部数据结构来模拟触发 SystemError 的场景。
获取 sys.modules：
modules = sys.modules：获取 sys 模块中维护的模块列表的内部引用。这是一个字典，键是模块名，值是模块对象。
打印修改前的模块列表长度：
print(f"Before modification: {len(modules)} modules")：打印当前已加载模块的数量。
尝试修改模块列表：
modules.clear()：尝试清空模块列表。虽然这个操作本身可能不会直接触发 SystemError（因为 sys.modules 通常是允许修改的），但类似的不当操作可能会。
注释掉的 sys.modules = None：这是一个极度危险的操作，它试图将 sys.modules 设置为 None，这几乎肯定会触发 SystemError 或导致解释器崩溃。由于这个操作太危险，我们在实际代码中将其注释掉。
手动抛出 SystemError：
raise SystemError(“Simulated SystemError due to improper modification of sys.modules”)：为了模拟可能的 SystemError 场景，我们手动抛出一个 SystemError。这仅用于教育目的。
捕获并处理 SystemError：
except SystemError as e：捕获 SystemError 并打印错误信息。
调用函数：
- trigger_system_error()：调用函数以触发可能的 SystemError。

运行结果

由于直接修改 sys.modules 并不会总是触发 SystemError（尽管这是非常危险和不推荐的做法），并且我们注释掉了最可能导致崩溃的代码，因此上述代码的运行结果是：

Before modification: X modules  # X 是当前已加载模块的数量  
Caught SystemError: Simulated SystemError due to improper modification of sys.modules

这里的 X 是运行代码时 Python 解释器中已加载的模块数量。Caught SystemError: Simulated SystemError due to improper modification of sys.modules 表示我们手动抛出的 SystemError 被成功捕获并打印了错误信息。

ValueError

ValueError 是 Python 中的一个标准异常类型，用于指示一个操作或函数接收到了一个具有正确类型但不满足所需值（即“合适”或“有效”的值）的参数。这种异常通常在数据类型正确但内容不合法时抛出，比如字符串解析为数字失败、索引超出预期范围、数据类型间的操作不兼容等场景。

案例

# 定义一个函数，用于根据用户输入的字符串计算其平方根  
def calculate_square_root(input_string):  
    try:  
        # 尝试将输入字符串转换为浮点数  
        number = float(input_string)  
          
        # 计算并返回该浮点数的平方根  
        # 使用math.sqrt函数，因此需要先导入math模块  
        import math  
        result = math.sqrt(number)  
          
        return result  
      
    # 捕获ValueError异常，如果输入字符串无法转换为浮点数或平方根计算失败（理论上math.sqrt不会因合法输入抛出ValueError）  
    except ValueError as e:  
        # 打印错误信息，并指出输入值不合法  
        print(f"ValueError: The input '{input_string}' is not a valid number for square root calculation.")  
        # 注意：在这个特定例子中，math.sqrt不会因合法输入（如负数，虽然结果会是复数，但不在ValueError的考虑范围内）抛出ValueError  
        # ValueError更可能是在float转换时抛出，比如输入为'abc'这样的非数字字符串  
  
# 测试函数，传入一个有效的数字字符串  
valid_input = "16"  
print(f"Square root of {valid_input} is {calculate_square_root(valid_input)}")  
  
# 测试函数，传入一个无效的数字字符串（将触发ValueError）  
invalid_input = "abc"  
calculate_square_root(invalid_input)

函数定义：
- def calculate_square_root(input_string): 定义了一个名为 calculate_square_root 的函数，它接受一个字符串参数 input_string。
异常处理：
- try: 开始一个异常处理块。
- number = float(input_string) 尝试将输入字符串转换为浮点数。如果转换失败（例如，输入字符串包含非数字字符），Python 将抛出 ValueError。
- import math 导入 math 模块，以便使用其 sqrt 函数计算平方根。
- result = math.sqrt(number) 计算并存储输入数字的平方根。
- return result 返回计算结果。
异常捕获：
- except ValueError as e: 捕获 ValueError 异常。e 是异常对象，包含了异常的详细信息（虽然在这个例子中我们并没有使用它）。
- print(f"ValueError: The input ‘{input_string}’ is not a valid number for square root calculation.") 打印一条错误信息，指出输入字符串不是有效的数字。
测试函数：
- valid_input = “16” 定义一个有效的数字字符串。
- print(f"Square root of {valid_input} is {calculate_square_root(valid_input)}") 调用函数并打印结果。对于输入 “16”，输出将是 Square root of 16 is 4.0。
- invalid_input = “abc” 定义一个无效的数字字符串。
- calculate_square_root(invalid_input) 调用函数并传入无效输入。这将触发 ValueError，并且由于我们在 except 块中捕获了该异常，所以将打印出错误信息，而不是让程序崩溃。

运行结果

Square root of 16 is 4.0  
ValueError: The input 'abc' is not a valid number for square root calculation.

对于有效的输入 “16”，函数成功计算并返回了平方根 4.0。对于无效的输入 “abc”，函数抛出了 ValueError，该异常被捕获，并且打印出了错误信息。

UnicodeError

UnicodeError 是 Python 中的一个异常类，用于处理与 Unicode 相关的错误。Unicode 是一种字符编码标准，它旨在涵盖世界上所有的书写系统，并为每个字符分配一个唯一的代码点。在 Python 中，处理 Unicode 字符串时可能会遇到各种错误，例如解码错误（当尝试将字节序列解码为 Unicode 字符串时，如果字节序列不是有效的 Unicode 编码，则会抛出此错误）、编码错误（当尝试将 Unicode 字符串编码为字节序列时，如果无法将某些字符转换为指定的编码，则会抛出此错误）等。

案例

# 定义一个函数，用于尝试将字节序列解码为Unicode字符串  
def decode_bytes_to_unicode(byte_sequence, encoding='utf-8'):  
    try:  
        # 尝试将字节序列解码为Unicode字符串  
        # encoding参数指定了字节序列的编码方式，默认为'utf-8'  
        decoded_string = byte_sequence.decode(encoding)  
          
        # 返回解码后的Unicode字符串  
        return decoded_string  
      
    # 捕获UnicodeDecodeError异常，它是UnicodeError的一个子类  
    except UnicodeDecodeError as e:  
        # 打印错误信息，包括错误的位置和原因  
        print(f"UnicodeDecodeError: {e.reason} at position {e.start} in byte sequence {byte_sequence}")  
        # 注意：e.reason给出了错误的原因，e.start给出了错误发生的位置（字节索引）  
  
# 定义一个函数，用于尝试将Unicode字符串编码为字节序列  
def encode_unicode_to_bytes(unicode_string, encoding='utf-8'):  
    try:  
        # 尝试将Unicode字符串编码为字节序列  
        # encoding参数指定了目标编码方式，默认为'utf-8'  
        encoded_bytes = unicode_string.encode(encoding)  
          
        # 返回编码后的字节序列  
        return encoded_bytes  
      
    # 捕获UnicodeEncodeError异常，它也是UnicodeError的一个子类  
    except UnicodeEncodeError as e:  
        # 打印错误信息，包括无法编码的字符和原因  
        # 注意：对于UnicodeEncodeError，e.object通常包含无法编码的Unicode字符  
        # 但由于Python 3.3之后，UnicodeEncodeError不再直接提供e.object属性，  
        # 我们可以通过e.start和e.end来获取无法编码字符的范围（在Unicode字符串中的位置）  
        # 并使用unicode_string[e.start:e.end]来获取这部分字符（如果需要的话）  
        # 但在这个例子中，我们仅打印错误信息和位置  
        print(f"UnicodeEncodeError: Could not encode part of the string at position {e.start}-{e.end}")  
  
# 测试解码函数，传入一个有效的字节序列（UTF-8编码）  
valid_bytes = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # UTF-8编码的'你好'  
print(f"Decoded string: {decode_bytes_to_unicode(valid_bytes)}")  
  
# 测试解码函数，传入一个无效的字节序列（不是有效的UTF-8编码）  
invalid_bytes = b'\x80abc'  # 无效的UTF-8字节序列  
decode_bytes_to_unicode(invalid_bytes)  
  
# 测试编码函数，传入一个有效的Unicode字符串  
valid_unicode = "你好，世界！"  
print(f"Encoded bytes: {encode_unicode_to_bytes(valid_unicode)}")  
  
# 测试编码函数，理论上不应该触发UnicodeEncodeError，因为UTF-8支持所有Unicode字符  
# 但为了演示如何处理这种异常，我们可以尝试使用一个不支持所有Unicode字符的编码（如ASCII）  
# 并故意传入一个非ASCII字符的Unicode字符串  
# 注意：在实际应用中，通常不会故意这样做，因为UTF-8是推荐使用的编码方式  
try:  
    problematic_unicode = "你好"  # 包含非ASCII字符的Unicode字符串  
    encode_unicode_to_bytes(problematic_unicode, encoding='ascii')  
except UnicodeEncodeError as e:  
    # 由于我们预期会捕获到这个异常，所以在这里处理它  
    print(f"Caught expected UnicodeEncodeError: {e}")

解码函数：
- decode_bytes_to_unicode(byte_sequence, encoding=‘utf-8’)：接受一个字节序列和一个可选的编码方式（默认为 ‘utf-8’），尝试将其解码为 Unicode 字符串。
- 在 try 块中，使用 byte_sequence.decode(encoding) 进行解码。
- 如果解码成功，返回解码后的 Unicode 字符串。
- 如果解码失败（例如，因为字节序列不是有效的 UTF-8 编码），则抛出 UnicodeDecodeError，并在 except 块中捕获该异常，打印错误信息。
编码函数：
- encode_unicode_to_bytes(unicode_string, encoding=‘utf-8’)：接受一个 Unicode 字符串和一个可选的编码方式（默认为 ‘utf-8’），尝试将其编码为字节序列。
- 在 try 块中，使用 unicode_string.encode(encoding) 进行编码。
- 如果编码成功，返回编码后的字节序列。
- 如果编码失败（在 Python 的标准库中，使用 ‘utf-8’ 编码通常不会失败，因为 ‘utf-8’ 支持所有 Unicode 字符；但为了演示，我们稍后会使用 ‘ascii’ 编码并预期会失败），则抛出 UnicodeEncodeError，并在 except 块中捕获该异常，打印错误信息。
测试代码：
- valid_bytes = b’\xe4\xbd\xa0\xe5\xa5\xbd’：一个有效的 UTF-8 编码的字节序列，表示中文 “你好”。
- decode_bytes_to_unicode(valid_bytes)：调用解码函数，应该成功返回 “你好”。
- invalid_bytes = b’\x80abc’：一个无效的 UTF-8 编码的字节序列。
- decode_bytes_to_unicode(invalid_bytes)：调用解码函数，应该触发 UnicodeDecodeError 并打印错误信息。
- valid_unicode = “你好，世界！”：一个有效的 Unicode 字符串。
- encode_unicode_to_bytes(valid_unicode)：调用编码函数，应该成功返回对应的 UTF-8 编码的字节序列。
- 尝试使用 ‘ascii’ 编码编码非 ASCII 字符的 Unicode 字符串，并预期会捕获到 UnicodeEncodeError。

运行结果

Decoded string: 你好  
UnicodeDecodeError: invalid start byte at position 0 in byte sequence b'\x80abc'  
Encoded bytes: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\95\x8c\xef\xbc\x81'  
Caught expected UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

对于有效的 UTF-8 编码字节序列，解码函数成功返回了 “你好”。
对于无效的 UTF-8 编码字节序列，解码函数触发了 UnicodeDecodeError 并打印了错误信息。
对于有效的 Unicode 字符串，编码函数成功返回了对应的 UTF-8 编码字节序列。
尝试使用 ‘ascii’ 编码编码非 ASCII 字符时，编码函数触发了 UnicodeEncodeError 并被捕获，打印了错误信息。

UnicodeDecodeError

UnicodeDecodeError 是 Python 中处理 Unicode 编码时遇到的一个具体异常类，它是 UnicodeError 的子类。这个异常通常在尝试将字节序列解码为 Unicode 字符串时抛出，如果字节序列不是有效的 Unicode 编码（例如，它可能包含了无法解码为有效 Unicode 字符的字节），就会触发这个错误。

案例

# 定义一个函数，用于尝试将字节序列解码为Unicode字符串  
def decode_bytes(byte_sequence, encoding='utf-8'):  
    """  
    尝试将给定的字节序列解码为Unicode字符串。  
      
    参数:  
    byte_sequence (bytes): 要解码的字节序列。  
    encoding (str): 使用的编码方式，默认为'utf-8'。  
      
    返回:  
    str: 解码后的Unicode字符串（如果成功）。  
      
    抛出:  
    UnicodeDecodeError: 如果字节序列不是有效的Unicode编码。  
    """  
    try:  
        # 使用指定的编码方式将字节序列解码为Unicode字符串  
        decoded_string = byte_sequence.decode(encoding)  
        return decoded_string  
    except UnicodeDecodeError as e:  
        # 捕获UnicodeDecodeError异常，并打印错误信息  
        # e.object 通常包含出错的字节序列（但在Python 3.3之后不再直接提供）  
        # e.start 和 e.end 指出出错字节在序列中的位置（字节索引）  
        # e.reason 提供了错误的具体原因  
        # 由于e.object不再直接可用，我们仅打印其他错误信息  
        print(f"UnicodeDecodeError: {e.reason} at position {e.start}-{e.end} in byte sequence {byte_sequence}")  
        # 可以选择重新抛出异常，或者进行其他错误处理  
        # raise  # 如果需要重新抛出异常，可以取消注释这行代码  
  
# 测试解码函数，传入一个有效的UTF-8编码的字节序列  
valid_utf8_bytes = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # UTF-8编码的'你好'  
print(f"Decoded valid UTF-8 bytes: {decode_bytes(valid_utf8_bytes)}")  
  
# 测试解码函数，传入一个无效的字节序列（不是有效的UTF-8编码）  
invalid_bytes = b'\x80\xab\xcd'  # 无效的UTF-8字节序列  
# 注意：这里我们不捕获异常，因此它将直接打印到控制台并由Python解释器处理  
decode_bytes(invalid_bytes)

解码函数：
- decode_bytes(byte_sequence, encoding=‘utf-8’)：这个函数接受一个字节序列 byte_sequence 和一个可选的编码方式 encoding（默认为 ‘utf-8’），并尝试将其解码为 Unicode 字符串。
- 在 try 块中，使用 byte_sequence.decode(encoding) 方法进行解码。
- 如果解码成功，函数返回解码后的 Unicode 字符串。
- 如果解码失败（因为字节序列不是有效的 UTF-8 编码），则抛出 UnicodeDecodeError 异常，并在 except 块中捕获它。在捕获异常时，打印出错误信息，包括错误的原因（e.reason）、出错字节在序列中的位置（e.start 和 e.end）以及出错的字节序列本身。
测试代码：
- valid_utf8_bytes = b’\xe4\xbd\xa0\xe5\xa5\xbd’：这是一个有效的 UTF-8 编码的字节序列，表示中文 “你好”。
- decode_bytes(valid_utf8_bytes)：调用解码函数，应该成功返回 “你好” 并打印出来。
- invalid_bytes = b’\x80\xab\xcd’：这是一个无效的 UTF-8 编码的字节序列。
- decode_bytes(invalid_bytes)：调用解码函数，由于字节序列无效，将触发 UnicodeDecodeError 异常。因为这里没有再次捕获异常，所以异常将被打印到控制台，并且程序将终止。

运行结果

Decoded valid UTF-8 bytes: 你好  
UnicodeDecodeError: invalid start byte at position 0-0 in byte sequence b'\x80\xab\xcd'  
Traceback (most recent call last):  
  File ".py", line 20, in <module>  
    decode_bytes(invalid_bytes)  
  File ".py", line 10, in decode_bytes  
    decoded_string = byte_sequence.decode(encoding)  
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0: invalid start byte

对于有效的 UTF-8 编码字节序列，解码函数成功返回了 “你好”。
对于无效的 UTF-8 编码字节序列，解码函数触发了 UnicodeDecodeError，并打印了错误信息。由于我们没有在 except 块中重新抛出异常（或者进行其他形式的错误处理），所以异常被传播到了顶层，并由 Python 解释器打印了标准的异常跟踪信息。在实际应用中，你可能希望在这里进行更细致的错误处理，比如记录日志、向用户显示友好的错误消息等。

UnicodeEncodeError

UnicodeEncodeError 是 Python 中处理 Unicode 编码时遇到的另一个具体异常类，它也是 UnicodeError 的子类。这个异常通常在尝试将 Unicode 字符串编码为字节序列时抛出，如果 Unicode 字符串包含无法用指定编码方式表示的字符，就会触发这个错误。

案例

# 定义一个函数，用于尝试将Unicode字符串编码为字节序列  
def encode_unicode(unicode_string, encoding='utf-8'):  
    """  
    尝试将给定的Unicode字符串编码为字节序列。  
      
    参数:  
    unicode_string (str): 要编码的Unicode字符串。  
    encoding (str): 使用的编码方式，默认为'utf-8'。  
      
    返回:  
    bytes: 编码后的字节序列（如果成功）。  
      
    抛出:  
    UnicodeEncodeError: 如果Unicode字符串包含无法用指定编码方式表示的字符。  
    """  
    try:  
        # 使用指定的编码方式将Unicode字符串编码为字节序列  
        encoded_bytes = unicode_string.encode(encoding)  
        return encoded_bytes  
    except UnicodeEncodeError as e:  
        # 捕获UnicodeEncodeError异常，并打印错误信息  
        # e.object 通常包含出错的Unicode字符串（但在Python 3.3之后不再直接提供）  
        # e.start 和 e.end 指出出错字符在字符串中的位置（字符索引）  
        # e.reason 提供了错误的具体原因  
        # 由于e.object不再直接可用，我们仅打印其他错误信息  
        print(f"UnicodeEncodeError: {e.reason} at position {e.start}-{e.end} in Unicode string '{unicode_string[:e.start] + '...' if e.start < len(unicode_string) else unicode_string}'")  
        # 可以选择重新抛出异常，或者进行其他错误处理  
        # raise  # 如果需要重新抛出异常，可以取消注释这行代码  
  
# 测试编码函数，传入一个包含普通ASCII字符的Unicode字符串  
ascii_string = "Hello, World!"  
print(f"Encoded ASCII string: {encode_unicode(ascii_string)}")  
  
# 测试编码函数，传入一个包含非ASCII字符（如中文）的Unicode字符串，并使用支持该字符的编码  
chinese_string = "你好，世界！"  
print(f"Encoded Chinese string: {encode_unicode(chinese_string)}")  
  
# 测试编码函数，传入一个包含非ASCII字符的Unicode字符串，但使用不支持该字符的编码（如ASCII）  
# 注意：这里我们不捕获异常，因此它将直接打印到控制台并由Python解释器处理  
unsupported_encoding_string = "你好，世界！"  
encode_unicode(unsupported_encoding_string, encoding='ascii')

编码函数：
- encode_unicode(unicode_string, encoding=‘utf-8’)：这个函数接受一个 Unicode 字符串 unicode_string 和一个可选的编码方式 encoding（默认为 ‘utf-8’），并尝试将其编码为字节序列。
- 在 try 块中，使用 unicode_string.encode(encoding) 方法进行编码。
- 如果编码成功，函数返回编码后的字节序列。
- 如果编码失败（因为 Unicode 字符串包含无法用指定编码方式表示的字符），则抛出 UnicodeEncodeError 异常，并在 except 块中捕获它。在捕获异常时，打印出错误信息，包括错误的原因（e.reason）、出错字符在字符串中的位置（e.start 和 e.end）以及出错的 Unicode 字符串的一部分（为了简洁，只打印出错位置之前的部分，并在其后添加 ‘…’）。
测试代码：
- ascii_string = “Hello, World!”：这是一个包含普通 ASCII 字符的 Unicode 字符串。
- encode_unicode(ascii_string)：调用编码函数，应该成功返回编码后的字节序列，并打印出来。
- chinese_string = “你好，世界！”：这是一个包含中文字符的 Unicode 字符串。
- encode_unicode(chinese_string)：调用编码函数，使用默认的 ‘utf-8’ 编码，应该成功返回编码后的字节序列，并打印出来。
- unsupported_encoding_string = “你好，世界！”：这是一个包含中文字符的 Unicode 字符串，但尝试使用不支持中文字符的 ‘ascii’ 编码进行编码。
- encode_unicode(unsupported_encoding_string, encoding=‘ascii’)：调用编码函数，由于 Unicode 字符串包含无法用 ‘ascii’ 编码表示的字符，将触发 UnicodeEncodeError 异常。因为这里没有再次捕获异常，所以异常将被打印到控制台，并且程序将终止。

运行结果

Encoded ASCII string: b'Hello, World!'  
Encoded Chinese string: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\95\x8c\xef\xbc\x81'  
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128) at position 0-2 in Unicode string '你好，...'  
Traceback (most recent call last):  
  File ".py", line 24, in <module>  
    encode_unicode(unsupported_encoding_string, encoding='ascii')  
  File ".py", line 10, in encode_unicode  
    encoded_bytes = unicode_string.encode(encoding)  
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

对于包含普通 ASCII 字符的 Unicode 字符串，编码函数成功返回了编码后的字节序列。
对于包含中文字符的 Unicode 字符串，使用 ‘utf-8’ 编码，编码函数成功返回了编码后的字节序列。
对于包含中文字符的 Unicode 字符串，但使用不支持中文字符的 ‘ascii’ 编码，编码函数触发了 UnicodeEncodeError，并打印了错误信息。由于我们没有在 except 块中重新抛出异常（或者进行其他形式的错误处理），所以异常被传播到了顶层，并由 Python 解释器打印了标准的异常跟踪信息。在实际应用中，你可能希望在这里进行更细致的错误处理，比如记录日志、向用户显示友好的错误消息等。

Warning

Warning 在 Python 中是一种用于向用户发出警告的信号，表明程序在运行时遇到了一些潜在的问题，但这些问题并不严重到需要立即停止程序执行的程度。Python 的 warnings 模块提供了发出警告、过滤警告和控制警告行为的功能。

案例

import warnings  
  
# 定义一个函数，该函数会发出一个警告  
def faulty_function(value):  
    """  
    一个会发出警告的函数。  
      
    如果传入的值为负数，则发出一个警告。  
      
    参数:  
    value (int or float): 要检查的值。  
      
    返回:  
    int or float: 传入的值（不变）。  
    """  
    if value < 0:  
        # 使用 warnings.warn() 发出警告  
        # 第一个参数是警告消息，第二个参数是警告类别（可选，默认为 UserWarning）  
        warnings.warn("Received a negative value, which might cause problems.", UserWarning)  
    return value  
  
# 定义一个自定义警告类别  
class CustomWarning(Warning):  
    """  
    自定义警告类别。  
      
    用于发出特定于我们应用程序的警告。  
    """  
    pass  
  
# 测试 faulty_function 函数  
print("Testing faulty_function with a positive value:")  
result_positive = faulty_function(10)  
print(f"Result: {result_positive}")  
  
print("\nTesting faulty_function with a negative value:")  
result_negative = faulty_function(-5)  
print(f"Result: {result_negative}")  
  
# 测试发出自定义警告  
print("\nTesting custom warning:")  
with warnings.catch_warnings(record=True) as w:  
    # 启用对特定警告类别的捕获  
    warnings.simplefilter("always", category=CustomWarning)  
    # 发出自定义警告  
    warnings.warn("This is a custom warning!", CustomWarning)  
    # 检查是否捕获到了自定义警告  
    assert len(w) == 1  
    assert issubclass(w[-1].category, CustomWarning)  
    assert str(w[-1].message) == "This is a custom warning!"  
  
# 打印捕获到的警告信息（可选）  
for warning in w:  
    print(f"Captured warning: {warning.message}")

导入 warnings 模块：
- import warnings：导入 Python 的 warnings 模块，以便使用其提供的警告功能。
定义 faulty_function 函数：
- faulty_function(value)：定义一个函数，该函数接受一个数值参数 value。
- 如果 value 为负数，则使用 warnings.warn() 发出一个 UserWarning 警告。
  函数返回传入的 value。
定义自定义警告类别 CustomWarning：
- class CustomWarning(Warning)：定义一个继承自 Warning 的自定义警告类别。
- 这允许我们发出特定于我们应用程序的警告。
测试 faulty_function 函数：
- 调用 faulty_function 函数两次，一次传入正数，一次传入负数。
- 观察输出，注意当传入负数时发出的警告。
测试发出自定义警告：
- 使用 warnings.catch_warnings(record=True) 上下文管理器捕获警告。
- 使用 warnings.simplefilter(“always”, category=CustomWarning) 启用对自定义警告类别的捕获。
- 发出一个自定义警告 CustomWarning。
- 使用断言检查是否捕获到了自定义警告，并验证警告的类别和消息。
打印捕获到的警告信息（可选）：
- 遍历捕获到的警告，并打印每个警告的消息。

运行结果

Testing faulty_function with a positive value:  
Result: 10  
  
Testing faulty_function with a negative value:  
/path/to/your/script.py:11: UserWarning: Received a negative value, which might cause problems.  
  warnings.warn("Received a negative value, which might cause problems.", UserWarning)  
Result: -5  
  
Testing custom warning:  
Captured warning: This is a custom warning!

当 faulty_function 函数传入正数时，没有发出警告，直接返回结果。
当 faulty_function 函数传入负数时，发出了一个 UserWarning 警告，并继续执行，返回结果。
在测试自定义警告时，成功捕获并验证了自定义警告，最后打印了捕获到的警告信息。

DeprecationWarning

DeprecationWarning 在 Python 中是一种特殊的警告类型，用于指示某个功能、模块、类或方法将在未来的版本中被移除或更改（即“弃用”）。这种警告的目的是给开发者足够的时间来适应这些变化，并更新他们的代码以避免在未来的版本中出现兼容性问题。

案例

import warnings  
  
# 定义一个将被弃用的函数  
def deprecated_function():  
    """  
    一个将被弃用的函数。  
      
    此函数在未来的版本中将被移除或更改。  
    """  
    # 使用 warnings.warn() 发出 DeprecationWarning  
    warnings.warn("This function is deprecated and will be removed in future versions.", DeprecationWarning)  
    # 模拟函数的功能（例如，打印一条消息）  
    print("Deprecated function called.")  
  
# 定义一个使用 deprecated_function 的新函数  
def use_deprecated_function():  
    """  
    调用已被弃用的函数。  
      
    此函数用于演示如何调用和使用被弃用的函数。  
    """  
    deprecated_function()  
  
# 设置警告过滤器，以控制 DeprecationWarning 的显示  
# 在这个例子中，我们将使用 'once' 模式，这样每个警告只会被打印一次  
warnings.simplefilter("once", category=DeprecationWarning)  
  
# 测试使用被弃用的函数  
print("Testing the use of deprecated function:")  
use_deprecated_function()  
  
# 再次调用以演示 'once' 过滤器的效果  
print("\nCalling the deprecated function again to demonstrate the 'once' filter:")  
use_deprecated_function()  
  
# 尝试捕获并处理 DeprecationWarning（可选）  
print("\nAttempting to capture and handle DeprecationWarning:")  
with warnings.catch_warnings(record=True) as w:  
    # 启用对 DeprecationWarning 的捕获  
    warnings.simplefilter("always", category=DeprecationWarning)  
    # 再次调用被弃用的函数  
    use_deprecated_function()  
    # 检查是否捕获到了预期的警告  
    assert len(w) == 1  
    assert issubclass(w[-1].category, DeprecationWarning)  
    assert str(w[-1].message) == "This function is deprecated and will be removed in future versions."  
  
# 打印捕获到的警告信息（可选）  
for warning in w:  
    print(f"Captured warning: {warning.message}")

导入 warnings 模块：
- import warnings：导入 Python 的 warnings 模块，以便使用其提供的警告功能。
定义被弃用的函数 deprecated_function：
- deprecated_function()：定义一个函数，该函数使用 warnings.warn() 发出一个 DeprecationWarning 警告。
- 警告消息指出该函数在未来的版本中将被移除或更改。
- 函数还模拟了一些功能（在这个例子中，只是打印一条消息）。
定义使用被弃用函数的新函数 use_deprecated_function：
- use_deprecated_function()：定义一个新函数，该函数调用 deprecated_function()。
- 这个新函数用于演示如何调用和使用被弃用的函数。
设置警告过滤器：
- warnings.simplefilter(“once”, category=DeprecationWarning)：设置警告过滤器，以控制 DeprecationWarning 的显示。
- 在这个例子中，使用 ‘once’ 模式，这样每个 DeprecationWarning 只会被打印一次，即使它多次被触发。
测试使用被弃用的函数：
- 调用 use_deprecated_function() 两次，以演示警告的显示和 ‘once’ 过滤器的效果。
- 第一次调用时会显示警告，第二次调用时不会重复显示。
尝试捕获并处理 DeprecationWarning（可选）：
- 使用 warnings.catch_warnings(record=True) 上下文管理器捕获警告。
- 启用对 DeprecationWarning 的捕获，并再次调用 use_deprecated_function()。
- 使用断言检查是否捕获到了预期的警告，并验证警告的类别和消息。
打印捕获到的警告信息（可选）：
- 遍历捕获到的警告，并打印每个警告的消息。

运行结果

Testing the use of deprecated function:  
/path/to/your/script.py:7: DeprecationWarning: This function is deprecated and will be removed in future versions.  
  warnings.warn("This function is deprecated and will be removed in future versions.", DeprecationWarning)  
Deprecated function called.  
  
Calling the deprecated function again to demonstrate the 'once' filter:  
Deprecated function called.  
  
Attempting to capture and handle DeprecationWarning:  
Captured warning: This function is deprecated and will be removed in future versions.  
Deprecated function called.

当第一次调用 use_deprecated_function() 时，显示了 DeprecationWarning 警告，并打印了被弃用函数的功能消息。
当第二次调用 use_deprecated_function() 时，由于 ‘once’ 过滤器的作用，没有重复显示警告，但仍然打印了被弃用函数的功能消息。
在尝试捕获并处理 DeprecationWarning 的部分，成功捕获了警告，并验证了其类别和消息。最后，再次调用了被弃用的函数以演示捕获过程，并打印了捕获到的警告信息。

FutureWarning

FutureWarning 在 Python 中是另一种特殊的警告类型，用于指示某个功能、模块、类或方法在未来的版本中可能会有行为上的变化，或者其当前的行为可能在将来的版本中不再被支持。这种警告的目的是让开发者意识到即将发生的变化，并提前做好准备，以避免未来的兼容性问题。

案例

import warnings  
  
# 定义一个将在未来版本中更改行为的函数  
def future_function(value):  
    """  
    一个在未来版本中行为可能会有所更改的函数。  
      
    此函数目前接受一个整数值并返回其平方，但在未来的版本中，  
    它可能会接受其他类型的输入并返回不同的结果。  
    """  
    # 使用 warnings.warn() 发出 FutureWarning  
    warnings.warn("The behavior of this function may change in future versions.", FutureWarning)  
    # 模拟函数的功能（例如，返回输入值的平方）  
    return value ** 2  
  
# 定义一个使用 future_function 的新函数  
def use_future_function():  
    """  
    调用可能会在未来版本中更改行为的函数。  
      
    此函数用于演示如何调用和使用可能在未来版本中更改的函数。  
    """  
    # 调用 future_function 并打印结果  
    result = future_function(5)  
    print(f"The result is: {result}")  
  
# 设置警告过滤器，以控制 FutureWarning 的显示  
# 在这个例子中，我们将使用 'always' 模式，以确保每个警告都会被打印  
warnings.simplefilter("always", category=FutureWarning)  
  
# 测试使用可能会在未来版本中更改行为的函数  
print("Testing the use of function with potential future changes:")  
use_future_function()  
  
# 尝试捕获并处理 FutureWarning（可选）  
print("\nAttempting to capture and handle FutureWarning:")  
with warnings.catch_warnings(record=True) as w:  
    # 启用对 FutureWarning 的捕获  
    # 这里不需要重新设置过滤器，因为我们已经全局设置了 'always'  
    # 但为了清晰起见，可以显式地指定类别  
    warnings.simplefilter("always", category=FutureWarning)  
    # 再次调用可能会在未来版本中更改的函数  
    use_future_function()  
    # 检查是否捕获到了预期的警告  
    assert len(w) == 1  
    assert issubclass(w[-1].category, FutureWarning)  
    assert str(w[-1].message) == "The behavior of this function may change in future versions."  
  
# 打印捕获到的警告信息（可选）  
for warning in w:  
    print(f"Captured warning: {warning.message}")

导入 warnings 模块：
- import warnings：导入 Python 的 warnings 模块，以便使用其提供的警告功能。
定义可能会在未来版本中更改行为的函数 future_function：
- future_function(value)：定义一个函数，该函数使用 warnings.warn() 发出一个 FutureWarning 警告。
- 警告消息指出该函数在未来的版本中行为可能会有所更改。
  函数还模拟了一些功能（在这个例子中，返回输入值的平方）。
定义使用可能会在未来版本中更改行为的函数的新函数 use_future_function：
- use_future_function()：定义一个新函数，该函数调用 future_function(value) 并打印结果。
- 这个新函数用于演示如何调用和使用可能会在未来版本中更改的函数。
设置警告过滤器：
- warnings.simplefilter(“always”, category=FutureWarning)：设置警告过滤器，以控制 FutureWarning 的显示。
- 在这个例子中，使用 ‘always’ 模式，以确保每个 FutureWarning 都会被打印，即使它多次被触发。
测试使用可能会在未来版本中更改行为的函数：
- 调用 use_future_function()，以演示警告的显示和函数的功能。
尝试捕获并处理 FutureWarning（可选）：
- 使用 warnings.catch_warnings(record=True) 上下文管理器捕获警告。
- 启用对 FutureWarning 的捕获，并再次调用 use_future_function()。
- 使用断言检查是否捕获到了预期的警告，并验证警告的类别和消息。
打印捕获到的警告信息（可选）：
- 遍历捕获到的警告，并打印每个警告的消息。

运行结果

Testing the use of function with potential future changes:  
/path/to/your/script.py:7: FutureWarning: The behavior of this function may change in future versions.  
  warnings.warn("The behavior of this function may change in future versions.", FutureWarning)  
The result is: 25  
  
Attempting to capture and handle FutureWarning:  
/path/to/your/script.py:7: FutureWarning: The behavior of this function may change in future versions.  
  warnings.warn("The behavior of this function may change in future versions.", FutureWarning)  
The result is: 25  
Captured warning: The behavior of this function may change in future versions.

当调用 use_future_function() 时，显示了 FutureWarning 警告，并打印了函数的结果。
在尝试捕获并处理 FutureWarning 的部分，成功捕获了警告，并验证了其类别和消息。最后，再次调用了可能会在未来版本中更改的函数以演示捕获过程，并打印了捕获到的警告信息以及函数的结果。

OverflowWarning

OverflowWarning 在 Python 中是一种警告类型，用于指示某个操作导致了数据溢出。数据溢出通常发生在数值运算中，当结果超出了变量类型能够表示的范围时。例如，在整数运算中，如果结果超出了整数的最大或最小可能值，就可能触发 OverflowWarning。

案例

import warnings  
import sys  
  
# 设置Python的整数类型为固定大小的整数（例如，32位），以更容易触发溢出  
# 注意：这个设置仅在Python的某些构建和平台上有效，且可能会影响整个解释器的行为  
# 在大多数现代Python安装中，整数是任意精度的，这意味着它们会自动扩展以适应更大的值  
# 这里我们只是为了演示目的而这样做，但请注意，这可能会改变Python的其他行为  
# 如果你无法设置固定大小的整数，可以跳过这一步，并直接进行大数运算来触发溢出  
# 警告：以下设置可能不适用于所有Python环境，并且可能会导致不可预测的行为  
try:  
    # 尝试设置整数的大小（仅在某些Python构建中有效）  
    sys.setintmax(2**31 - 1)  # 设置整数最大值  
    sys.setintmin(-2**31)     # 设置整数最小值  
except AttributeError:  
    # 如果上述方法无效（很可能在大多数情况下都会无效），则打印一条消息  
    print("Warning: Setting integer size is not supported in this Python build.")  
  
# 由于大多数现代Python解释器中的整数是任意精度的，  
# 我们将直接进行一个大数运算来尝试触发OverflowWarning（尽管这通常不会成功）  
# 或者，我们可以使用numpy等库中的固定精度整数类型来演示溢出  
# 但为了保持简单，这里我们仍然使用Python内置的整数类型，并依赖解释器的警告系统  
  
# 定义一个函数，该函数执行可能导致溢出的运算  
def overflow_function():  
    """  
    执行一个大数运算，尝试触发OverflowWarning。  
      
    由于Python的整数通常是任意精度的，这个警告可能不会在现代Python解释器中触发。  
    但是，如果整数大小被限制（如上面的尝试所示），或者使用了固定精度的整数类型（如numpy.int32），  
    则这个警告可能会被触发。  
    """  
    # 选择两个大数进行乘法运算  
    large_number_1 = 2**30  
    large_number_2 = 2**30 + 1  
      
    # 尝试捕获并处理OverflowWarning（尽管在标准Python中这通常不会成功）  
    with warnings.catch_warnings(record=True) as w:  
        # 启用对特定警告类别的捕获（但注意，OverflowWarning在标准Python整数运算中可能不会被触发）  
        warnings.simplefilter("always", category=OverflowWarning)  
          
        # 执行可能导致溢出的运算  
        result = large_number_1 * large_number_2  
          
        # 检查是否捕获到了预期的警告（在标准Python中，这通常会失败）  
        # 注意：下面的断言在大多数现代Python环境中都会失败，因为整数是任意精度的  
        assert len(w) == 0, f"Unexpected warning captured: {w}" if w else "No warning captured as expected."  
        # 如果捕获到了警告，我们可以打印它（但在这个例子中通常不会发生）  
        # for warning in w:  
        #     print(f"Captured warning: {warning.message}")  
      
    # 打印运算结果（在标准Python中，这将是一个非常大的整数，不会溢出）  
    print(f"The result of the overflow operation is: {result}")  
  
# 调用可能触发溢出的函数  
overflow_function()

尝试设置整数大小：
- 这部分代码尝试使用 sys.setintmax() 和 sys.setintmin() 来设置整数的最大值和最小值。然而，需要注意的是，这些函数在大多数现代Python解释器中并不存在，因为Python的整数通常是任意精度的。因此，这部分代码很可能会引发 AttributeError，并且打印出一条警告消息。
定义可能触发溢出的函数 overflow_function：
- 这个函数选择两个大数进行乘法运算，并尝试捕获 OverflowWarning。然而，由于Python的整数是任意精度的，这个警告通常不会被触发。
- 使用了 warnings.catch_warnings() 上下文管理器来捕获警告，并设置了过滤器以捕获 OverflowWarning。但是，由于整数溢出通常不会发生，因此捕获到的警告列表将是空的。
调用可能触发溢出的函数：
- 调用 overflow_function() 函数，并打印运算结果。在标准Python环境中，这将是一个非常大的整数，而不会触发溢出或警告。

运行结果（基于标准Python环境）

Warning: Setting integer size is not supported in this Python build.  
The result of the overflow operation is: 4294967296

由于整数大小设置失败（AttributeError），打印出警告消息。
运算结果是一个非常大的整数（在这个例子中，是 4294967296），没有触发溢出或警告。

注意：在标准Python环境中，由于整数是任意精度的，因此很难通过简单的整数运算来触发 OverflowWarning。如果你想要演示溢出警告，你可能需要使用支持固定精度整数类型的库（如NumPy）或编写特定于平台的代码来限制整数的大小。然而，这超出了本示例的范围，并且可能会引入额外的复杂性。

PendingDeprecationWarning

PendingDeprecationWarning 是 Python 中的一个警告类型，用于指示某个特性或功能将在未来的版本中被弃用（即不再推荐使用或支持）。这种警告通常会给开发者一些时间来适应即将发生的变化，并更新他们的代码以避免使用即将被弃用的特性。

案例

import warnings  
  
# 定义一个函数，该函数使用了一个即将被弃用的特性  
def use_pending_deprecated_feature():  
    """  
    演示使用即将被弃用的特性，并触发PendingDeprecationWarning。  
      
    在这个例子中，我们并没有实际使用Python标准库中的任何即将被弃用的特性，  
    因为这样的特性很难预测，并且会随时间而变化。因此，我们将模拟一个情况，  
    通过手动触发PendingDeprecationWarning来演示。  
    """  
    # 触发PendingDeprecationWarning  
    warnings.warn("This feature will be deprecated in future versions.", PendingDeprecationWarning)  
      
    # 假设这里有一些代码使用了即将被弃用的特性（实际代码已省略）  
    # ...  
    # 但为了演示目的，我们仅仅打印一条消息来表示使用了该特性  
    print("Used a pending deprecated feature (simulated).")  
  
# 定义一个函数，用于捕获并处理警告  
def handle_warnings():  
    """  
    捕获并处理PendingDeprecationWarning，打印出警告信息。  
    """  
    # 使用warnings.catch_warnings()上下文管理器来捕获警告  
    with warnings.catch_warnings(record=True) as w:  
        # 设置警告过滤器，仅捕获PendingDeprecationWarning  
        warnings.simplefilter("always", category=PendingDeprecationWarning)  
          
        # 调用使用即将被弃用特性的函数  
        use_pending_deprecated_feature()  
          
        # 检查是否捕获到了预期的警告  
        for warning in w:  
            # 打印警告信息  
            print(f"Captured warning: {warning.message}")  
            # 打印警告的类别（应该是PendingDeprecationWarning）  
            print(f"Warning category: {warning.category}")  
  
# 调用处理警告的函数  
handle_warnings()

定义 use_pending_deprecated_feature 函数：
- 这个函数模拟了使用即将被弃用的特性的情况。它使用 warnings.warn() 函数手动触发一个 PendingDeprecationWarning。
- 接着，它打印一条消息来表示（模拟）使用了即将被弃用的特性。
定义 handle_warnings 函数：
- 这个函数用于捕获并处理 PendingDeprecationWarning。
- 它使用 warnings.catch_warnings() 上下文管理器来捕获警告，并将 record=True 参数设置为 True 以记录捕获到的警告。
- 使用 warnings.simplefilter() 函数设置警告过滤器，以便仅捕获 PendingDeprecationWarning 类型的警告。
- 调用 use_pending_deprecated_feature() 函数来触发警告。
- 遍历捕获到的警告列表，并打印每个警告的信息和类别。
调用 handle_warnings 函数：
- 最后，调用 handle_warnings() 函数来执行上述过程。

运行结果

Used a pending deprecated feature (simulated).  
Captured warning: This feature will be deprecated in future versions.  
Warning category: <class 'warnings.PendingDeprecationWarning'>

首先，打印出模拟使用即将被弃用特性的消息。
然后，捕获到 PendingDeprecationWarning，并打印出警告信息和警告的类别。

RuntimeWarning

RuntimeWarning 是 Python 中的一个警告类型，它通常在运行时由解释器或某些库函数发出，以指示可能存在的问题或不当的用法，这些问题可能不会立即导致程序崩溃，但可能会导致意外的行为或效率问题。RuntimeWarning 是一种较为通用的警告，用于涵盖多种可能的运行时问题。

案例

import numpy as np  
import warnings  
  
# 定义一个函数，该函数会触发一个RuntimeWarning  
def trigger_runtime_warning():  
    """  
    演示触发RuntimeWarning的情况。  
      
    在这个例子中，我们将使用NumPy库来创建一个非常大的浮点数数组，并计算其平均值。  
    由于浮点数的精度限制，当数组元素非常大时，计算平均值可能会导致精度损失，  
    从而触发RuntimeWarning。注意，这个警告可能不会在所有的Python环境或NumPy版本中  
    都出现，因为它取决于底层的浮点数运算实现。  
    """  
    # 创建一个非常大的浮点数数组  
    large_numbers = np.array([1e+308] * 10000, dtype=np.float64)  
      
    # 对数组中的每个元素加上一个很小的数，以模拟可能的精度问题  
    perturbed_numbers = large_numbers + 1e-10  
      
    # 计算数组的平均值，这可能会触发RuntimeWarning  
    # 警告内容可能类似于：“Mean of empty slice”或“overflow encountered in double_scalars”  
    # 但请注意，具体的警告内容可能因NumPy版本和底层硬件/操作系统而异  
    mean_value = np.mean(perturbed_numbers)  
      
    # 打印计算得到的平均值（尽管有警告，但计算仍会进行）  
    print(f"Mean value: {mean_value}")  
  
# 定义一个函数，用于捕获并处理警告  
def handle_warnings():  
    """  
    捕获并处理RuntimeWarning，打印出警告信息。  
    """  
    # 使用warnings.catch_warnings()上下文管理器来捕获警告  
    with warnings.catch_warnings(record=True) as w:  
        # 设置警告过滤器，仅捕获RuntimeWarning  
        warnings.simplefilter("always", category=RuntimeWarning)  
          
        # 调用触发RuntimeWarning的函数  
        trigger_runtime_warning()  
          
        # 检查是否捕获到了预期的警告  
        for warning in w:  
            # 打印警告信息  
            print(f"Captured warning: {warning.message}")  
            # 打印警告的类别（应该是RuntimeWarning）  
            print(f"Warning category: {warning.category}")  
            # 打印触发警告的文件名和行号（如果可用）  
            print(f"Warning filename: {warning.filename}")  
            print(f"Warning lineno: {warning.lineno}")  
  
# 调用处理警告的函数  
handle_warnings()

定义 trigger_runtime_warning 函数：
- 这个函数创建了一个包含非常大浮点数的 NumPy 数组，并对每个元素加上一个很小的数。
- 然后，它尝试计算这个数组的平均值，这个操作可能会因为浮点数的精度问题或溢出而触发 RuntimeWarning。
- 请注意，由于浮点数的运算特性和硬件/操作系统的差异，这个警告可能不会在所有环境中都出现。
定义 handle_warnings 函数：
- 这个函数用于捕获并处理 RuntimeWarning。
- 它使用 warnings.catch_warnings() 上下文管理器来捕获警告，并将 record=True 参数设置为 True 以记录捕获到的警告。
- 使用 warnings.simplefilter() 函数设置警告过滤器，以便仅捕获 RuntimeWarning 类型的警告。
- 调用 trigger_runtime_warning() 函数来触发警告。
- 遍历捕获到的警告列表，并打印每个警告的信息、类别、触发警告的文件名和行号。
调用 handle_warnings 函数：
- 最后，调用 handle_warnings() 函数来执行上述过程。

运行结果

由于 RuntimeWarning 的触发取决于多种因素（如 NumPy 版本、底层硬件和操作系统），因此具体的警告信息可能会有所不同。

Mean value: 1.0000000000000002e+308  
Captured warning: overflow encountered in double_scalars  
Warning category: <class 'warnings.RuntimeWarning'>  
Warning filename: /path/to/your/script.py  
Warning lineno: 12  # 这里是触发警告的代码所在的行号

首先，打印出计算得到的平均值（尽管有警告，但计算通常仍会进行）。
然后，捕获到 RuntimeWarning，并打印出警告信息、警告的类别、触发警告的文件名和行号。

SyntaxWarning

SyntaxWarning 是 Python 中的一个警告类型，它通常在代码解析阶段由解释器发出，以指示语法上可能存在的问题或不当的用法。这些警告通常不会阻止程序的执行，但会提醒开发者注意潜在的代码问题，这些问题可能会导致意外的行为或未来的兼容性问题。

案例

import warnings  
  
# 定义一个函数，该函数会触发一个SyntaxWarning  
def trigger_syntax_warning():  
    """  
    演示触发SyntaxWarning的情况。  
      
    在这个例子中，我们将使用不推荐的语法特性，比如使用旧的八进制字面量表示法。  
    在Python 3中，旧的八进制字面量（以'0'开头的数字，如0755）已经被废弃，并推荐使用新的表示法（以'0o'开头，如0o755）。  
    使用旧的表示法会触发SyntaxWarning。  
    """  
    # 使用旧的八进制字面量表示法  
    old_octal = 0755  # 这行会触发SyntaxWarning  
      
    # 打印八进制值（尽管有警告，但代码仍会执行）  
    print(f"Old octal value: {old_octal}")  
  
# 定义一个函数，用于捕获并处理警告  
def handle_warnings():  
    """  
    捕获并处理SyntaxWarning，打印出警告信息。  
    """  
    # 使用warnings.catch_warnings()上下文管理器来捕获警告  
    with warnings.catch_warnings(record=True) as w:  
        # 设置警告过滤器，仅捕获SyntaxWarning  
        warnings.simplefilter("always", category=SyntaxWarning)  
          
        # 调用触发SyntaxWarning的函数  
        trigger_syntax_warning()  
          
        # 检查是否捕获到了预期的警告  
        for warning in w:  
            # 打印警告信息  
            print(f"Captured warning: {warning.message}")  
            # 打印警告的类别（应该是SyntaxWarning）  
            print(f"Warning category: {warning.category}")  
            # 打印触发警告的文件名和行号（如果可用）  
            print(f"Warning filename: {warning.filename}")  
            print(f"Warning lineno: {warning.lineno}")  
  
# 调用处理警告的函数  
handle_warnings()

定义 trigger_syntax_warning 函数：
- 这个函数演示了如何触发 SyntaxWarning。在这个例子中，它使用了旧的八进制字面量表示法（以 0 开头，如 0755）。
- 在 Python 3 中，这种表示法已经被废弃，并推荐使用新的表示法（以 0o 开头，如 0o755）。使用旧的表示法会触发 SyntaxWarning。
定义 handle_warnings 函数：
- 这个函数用于捕获并处理 SyntaxWarning。
- 它使用 warnings.catch_warnings() 上下文管理器来捕获警告，并将 record=True 参数设置为 True 以记录捕获到的警告。
- 使用 warnings.simplefilter() 函数设置警告过滤器，以便仅捕获 SyntaxWarning 类型的警告。
- 调用 trigger_syntax_warning() 函数来触发警告。
- 遍历捕获到的警告列表，并打印每个警告的信息、类别、触发警告的文件名和行号。
调用 handle_warnings 函数：
- 最后，调用 handle_warnings() 函数来执行上述过程。

运行结果

由于 SyntaxWarning 是在代码解析阶段发出的，因此它的行为可能与解释器的具体实现和版本有关。在 Python 3.x 的某些版本中，使用旧的八进制字面量表示法可能会直接触发 DeprecationWarning 而不是 SyntaxWarning，或者在某些严格模式下可能会直接报错。然而，为了做一个案例，我们假设在当前环境中它确实触发了 SyntaxWarning。

Old octal value: 493  # 0755 在十进制中的值  
Captured warning: syntax warning: '0755' is an octal literal in Python 2.x and will be treated as an integer in Python 3.x (use 0o755 for octal integers)  
Warning category: <class 'warnings.SyntaxWarning'>  
Warning filename: /path/to/your/script.py  
Warning lineno: 12  # 这里是触发警告的代码所在的行号

首先，打印出旧的八进制字面量在十进制中的值（尽管有警告，但代码仍会执行）。
然后，捕获到 SyntaxWarning，并打印出警告信息、警告的类别、触发警告的文件名和行号。

请注意，由于 Python 的版本和解释器实现可能会有所不同，因此在实际开发中，当你遇到 SyntaxWarning 时，应该仔细分析警告信息，并考虑更新你的代码以使用推荐的语法特性。在上面的例子中，你应该将 0755 替换为 0o755 以避免未来的兼容性问题。

UserWarning

UserWarning 是 Python 中 warnings 模块提供的一种警告类型，用于指示用户定义的、非关键的警告信息。与 SyntaxWarning 不同，UserWarning 是由开发者在代码中显式触发的，通常用于提醒用户注意某些可能的问题、非标准行为或即将发生的变更。

案例

import warnings  
  
# 定义一个函数，该函数会触发一个UserWarning  
def trigger_user_warning():  
    """  
    演示触发UserWarning的情况。  
      
    在这个例子中，我们将使用warnings.warn()函数来触发一个UserWarning。  
    这个函数接受两个主要参数：警告消息和一个可选的警告类别（默认为UserWarning）。  
    """  
    # 触发UserWarning，并传递一个警告消息  
    warnings.warn("This is a user-defined warning message.", UserWarning)  # 这行会触发UserWarning  
  
# 定义一个函数，用于捕获并处理警告  
def handle_warnings():  
    """  
    捕获并处理UserWarning，打印出警告信息。  
    """  
    # 使用warnings.catch_warnings()上下文管理器来捕获警告  
    with warnings.catch_warnings(record=True) as w:  
        # 设置警告过滤器，仅捕获UserWarning  
        warnings.simplefilter("always", category=UserWarning)  
          
        # 调用触发UserWarning的函数  
        trigger_user_warning()  
          
        # 检查是否捕获到了预期的警告  
        for warning in w:  
            # 打印警告信息  
            print(f"Captured warning: {warning.message}")  
            # 打印警告的类别（应该是UserWarning）  
            print(f"Warning category: {warning.category}")  
            # 打印触发警告的文件名和行号（如果可用）  
            print(f"Warning filename: {warning.filename}")  
            print(f"Warning lineno: {warning.lineno}")  
  
# 调用处理警告的函数  
handle_warnings()

导入 warnings 模块：
- warnings 模块提供了警告控制的基本功能。
定义 trigger_user_warning 函数：
- 这个函数演示了如何触发 UserWarning。
- 使用 warnings.warn() 函数来触发警告，传递一个警告消息和一个警告类别（在这里是 UserWarning，但也可以省略，因为 UserWarning 是默认类别）。
定义 handle_warnings 函数：
- 这个函数用于捕获并处理 UserWarning。
- 使用 warnings.catch_warnings() 上下文管理器来捕获警告，并将 record=True 参数设置为 True 以记录捕获到的警告。
- 使用 warnings.simplefilter() 函数设置警告过滤器，以便仅捕获 UserWarning 类型的警告。
- 调用 trigger_user_warning() 函数来触发警告。
- 遍历捕获到的警告列表，并打印每个警告的信息、类别、触发警告的文件名和行号。
调用 handle_warnings 函数：
- 最后，调用 handle_warnings() 函数来执行上述过程。

运行结果

Captured warning: This is a user-defined warning message.  
Warning category: <class 'warnings.UserWarning'>  
Warning filename: /path/to/your/script.py  
Warning lineno: 13  # 这里是触发警告的代码所在的行号

首先，打印出捕获到的警告信息，即传递给 warnings.warn() 函数的消息。
然后，打印出警告的类别，这里应该是。
接着，打印出触发警告的文件名和行号，这有助于定位代码中的问题。

在实际开发中，UserWarning 可以用于多种场景，比如提醒用户某个功能即将被弃用、某个参数的值不在推荐范围内、或者某个操作可能会导致意外的结果等。通过捕获和处理这些警告，开发者可以提供更丰富的用户反馈，并帮助用户避免潜在的问题。

FileNotFoundError

FileNotFoundError 是 Python 中用于处理文件未找到异常的一个内置异常类。它继承自 OSError 类，通常在你尝试打开一个不存在的文件时会触发。这种异常对于文件操作中的错误处理非常重要，因为它允许程序在遇到问题时能够优雅地处理，而不是直接崩溃。

异常说明

类名: FileNotFoundError
继承自: OSError
触发条件: 尝试打开或操作一个不存在的文件时。
典型用途: 在文件操作中，用于捕获文件未找到的异常，并执行相应的错误处理逻辑。

异常属性

errno: 错误编号，是一个整数，标识特定的错误类型。
strerror: 错误描述，是一个字符串，描述了错误的详细信息。
filename: 引发错误的文件名，是一个字符串。
with_traceback(): 用于异常回溯的方法。

案例

import os  
  
def read_file(file_path):  
    """  
    尝试读取并打印文件内容。  
      
    参数:  
    file_path (str): 要读取的文件的路径。  
      
    返回:  
    None  
      
    异常:  
    FileNotFoundError: 如果文件不存在，则抛出此异常。  
    """  
    try:  
        # 尝试打开文件并读取内容  
        with open(file_path, 'r') as file:  
            content = file.read()  
            print("文件内容:")  
            print(content)  
    except FileNotFoundError as e:  
        # 捕获 FileNotFoundError 异常  
        print(f"文件未找到: {e.filename}")  
        print(f"错误描述: {e.strerror}")  
        # 可以在这里添加其他错误处理逻辑，比如记录日志、重试等  
    except Exception as e:  
        # 捕获其他可能的异常  
        print(f"发生了一个未知错误: {e}")  
  
# 示例文件路径，确保这个路径指向一个不存在的文件  
non_existent_file_path = 'non_existent_file.txt'  
  
# 检查文件是否存在，以确保演示效果  
if not os.path.exists(non_existent_file_path):  
    print(f"文件 {non_existent_file_path} 不存在，将演示 FileNotFoundError 异常处理。")  
  
# 调用函数读取文件  
read_file(non_existent_file_path)

导入模块: import os 用于操作系统相关的功能，这里主要用于检查文件是否存在。
定义函数: read_file(file_path) 尝试读取文件内容。
尝试读取文件: 使用 with open(file_path, ‘r’) as file: 尝试打开文件。如果文件不存在，将抛出 FileNotFoundError。
捕获异常:
- except FileNotFoundError as e: 捕获 FileNotFoundError 并打印文件名和错误描述。
- except Exception as e: 捕获其他所有异常类型，以防万一。
检查文件是否存在: 使用 os.path.exists(non_existent_file_path) 确保文件不存在，以便演示异常处理。
调用函数: 调用 read_file(non_existent_file_path) 尝试读取文件，并触发 FileNotFoundError 异常处理逻辑。

运行结果

文件 non_existent_file.txt 不存在，将演示 FileNotFoundError 异常处理。  
文件未找到: non_existent_file.txt  
错误描述: [Errno 2] No such file or directory: 'non_existent_file.txt'

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

异常类型

SystemError

案例

运行结果

ValueError

案例

运行结果

UnicodeError

案例

运行结果

UnicodeDecodeError

案例

运行结果

UnicodeEncodeError

案例

运行结果

Warning

案例

运行结果

DeprecationWarning

案例

运行结果

FutureWarning

案例

运行结果

OverflowWarning

案例

运行结果（基于标准Python环境）

PendingDeprecationWarning

案例

运行结果

RuntimeWarning

案例

运行结果

SyntaxWarning

案例

运行结果

UserWarning

案例

运行结果

FileNotFoundError

异常说明

异常属性

案例

运行结果

推荐阅读

Python基础

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

Python刷题面试宝典

Flink入门到就业

你可能感兴趣的:(最新Python入门基础合集,python,面试,异常处理,BUG,异常类型,职场和发展,改行学it)