什么是异常
在Python中，异常是指在程序执行过程中出现的错误或异常情况。
当Python解释器无法执行代码时，它会引发异常，这可能是由于语法错误、运行时错误或逻辑错误等原因引起的。
我们经常会碰到诸如以下的异常：
SyntaxError 异常
Python语言拥有自己的语法格式和规则。如果我们未能遵守这些规则，就会导致异常的出现。
In [52]: pint("Hello, World!")---------------------------------------------------------------------------NameError Traceback (most recent call last)Input In [52], in <cell line: 1>()----> 1 pint("Hello, World!")
NameError: name 'pint' is not defined
复制代码
正确语法为print("Hello, World!")
NameError 异常
NameError异常通常在代码中引用了未声明的变量或者不存在的函数或方法时触发。
In [53]: print(my_variable) # 使用了未定义的变量---------------------------------------------------------------------------NameError Traceback (most recent call last)Input In [53], in <cell line: 1>()----> 1 print(my_variable)
NameError: name 'my_variable' is not defined
复制代码
KeyError 异常
KeyError异常通常在尝试访问字典中不存在的键时触发。
In [54]: my_dict = {'a': 1, 'b': 2} ...: print(my_dict['c']) # 尝试访问字典中不存在的键---------------------------------------------------------------------------KeyError Traceback (most recent call last)Input In [54], in <cell line: 2>() 1 my_dict = {'a': 1, 'b': 2}----> 2 print(my_dict['c'])
KeyError: 'c'
复制代码
FileNotFoundError（文件未找到错误）
FileNotFoundError异常通常在尝试打开或操作一个并不存在的文件时触发。
In [55]: file = open('non_existent_file.txt', 'r')---------------------------------------------------------------------------FileNotFoundError Traceback (most recent call last)Input In [55], in <cell line: 1>()----> 1 file = open('non_existent_file.txt', 'r')
FileNotFoundError: [Errno 2] No such file or directory: 'non_existent_file.txt'
复制代码
异常可以分为两种类型：
语法错误（Syntax Errors）：这类错误也称为解析错误，是由于代码不符合 Python 语法规则而引起的。比如，拼写错误、缺少括号、不正确的缩进等。
运行时错误（Runtime Errors）：这类错误在程序运行时发生，通常是由于程序的逻辑错误或外部环境引起的。常见的运行时错误包括除以零（ZeroDivisionError）、访问不存在的索引（IndexError）、使用未定义变量（NameError）等。
异常处理机制允许我们捕获并处理这些异常，以避免程序崩溃并提供错误处理和恢复的机会。
在Python中，我们可以使用try-except语句来捕获并处理异常。try语句块用于执行可能会引发异常的代码，而except语句块用于处理异常情况。例如：
try: # 可能会引发异常的代码 result = 10 / 0except ZeroDivisionError: # 处理除以零的异常 print("除数不能为零！")
复制代码
除了使用try-except语句来处理异常，还可以使用其他相关的结构和关键字，如try-except-else、try-except-finally等，来更灵活地处理异常情况。
异常的分类
在Python中，异常可以进一步分为内置异常（Built-in Exceptions）和自定义异常（Custom Exceptions）。
内置异常（Built-in Exceptions）：Python提供了一系列内置的异常类来表示不同类型的错误或异常情况。这些异常类都是内置在Python解释器中的，开发者可以直接使用它们来处理程序执行过程中可能出现的各种错误。常见的内置异常包括：
-- SystemExit # 解释器请求退出-- KeyboardInterrupt # 用户中断执行(通常是输入^C)-- GeneratorExit # 生成器(generator)发生异常来通知退出 -- StopIteration # 迭代器没有更多的值 -- StopAsyncIteration # 必须通过异步迭代器对象的__anext__()方法引发以停止迭代 -- ArithmeticError # 各种算术错误引发的内置异常的基类 | -- FloatingPointError # 浮点计算错误 | -- OverflowError # 数值运算结果太大无法表示 | -- ZeroDivisionError # 除(或取模)零 (所有数据类型) -- AssertionError # 当assert语句失败时引发 -- AttributeError # 属性引用或赋值失败 -- BufferError # 无法执行与缓冲区相关的操作时引发 -- EOFError # 当input()函数在没有读取任何数据的情况下达到文件结束条件(EOF)时引发 -- ImportError # 导入模块/对象失败 | -- ModuleNotFoundError # 无法找到模块或在在sys.modules中找到None -- LookupError # 映射或序列上使用的键或索引无效时引发的异常的基类 | -- IndexError # 序列中没有此索引(index) | -- KeyError # 映射中没有这个键 -- MemoryError # 内存溢出错误(对于Python 解释器不是致命的) -- NameError # 未声明/初始化对象 (没有属性) | -- UnboundLocalError # 访问未初始化的本地变量 -- OSError # 操作系统错误，EnvironmentError，IOError，WindowsError，socket.error，select.error和mmap.error已合并到OSError中，构造函数可能返回子类 | -- BlockingIOError # 操作将阻塞对象(e.g. socket)设置为非阻塞操作 | -- ChildProcessError # 在子进程上的操作失败 | -- ConnectionError # 与连接相关的异常的基类 | | -- BrokenPipeError # 另一端关闭时尝试写入管道或试图在已关闭写入的套接字上写入 | | -- ConnectionAbortedError # 连接尝试被对等方中止 | | -- ConnectionRefusedError # 连接尝试被对等方拒绝 | | -- ConnectionResetError # 连接由对等方重置 | -- FileExistsError # 创建已存在的文件或目录 | -- FileNotFoundError # 请求不存在的文件或目录 | -- InterruptedError # 系统调用被输入信号中断 | -- IsADirectoryError # 在目录上请求文件操作(例如 os.remove()) | -- NotADirectoryError # 在不是目录的事物上请求目录操作(例如 os.listdir()) | -- PermissionError # 尝试在没有足够访问权限的情况下运行操作 | -- ProcessLookupError # 给定进程不存在 | -- TimeoutError # 系统函数在系统级别超时 -- ReferenceError # weakref.proxy()函数创建的弱引用试图访问已经垃圾回收了的对象 -- RuntimeError # 在检测到不属于任何其他类别的错误时触发 | -- NotImplementedError # 在用户定义的基类中，抽象方法要求派生类重写该方法或者正在开发的类指示仍然需要添加实际实现 | -- RecursionError # 解释器检测到超出最大递归深度 -- SyntaxError # Python 语法错误 | -- IndentationError # 缩进错误 | -- TabError # Tab和空格混用 -- SystemError # 解释器发现内部错误 -- TypeError # 操作或函数应用于不适当类型的对象 -- ValueError # 操作或函数接收到具有正确类型但值不合适的参数 | -- UnicodeError # 发生与Unicode相关的编码或解码错误 | -- UnicodeDecodeError # Unicode解码错误 | -- UnicodeEncodeError # Unicode编码错误 | -- UnicodeTranslateError # Unicode转码错误 -- Warning # 警告的基类 -- DeprecationWarning # 有关已弃用功能的警告的基类 -- PendingDeprecationWarning # 有关不推荐使用功能的警告的基类 -- RuntimeWarning # 有关可疑的运行时行为的警告的基类 -- SyntaxWarning # 关于可疑语法警告的基类 -- UserWarning # 用户代码生成警告的基类 -- FutureWarning # 有关已弃用功能的警告的基类 -- ImportWarning # 关于模块导入时可能出错的警告的基类 -- UnicodeWarning # 与Unicode相关的警告的基类 -- BytesWarning # 与bytes和bytearray相关的警告的基类 -- ResourceWarning # 与资源使用相关的警告的基类。被默认警告过滤器忽略。异常捕获与处理
复制代码
完整的内置异常列表可以在 Python 官方文档中找到。docs.python.org/3/library/e…
自定义异常（Custom Exceptions）：除了使用Python提供的内置异常类外，开发者还可以根据自己的需求定义自己的异常类。通过定义自定义异常类，开发者可以更好地组织和管理程序中可能出现的特定类型的错误。自定义异常类通常继承自Python内置的Exception类或其子类。例如：
class CustomException(Exception): def __init__(self, message): self.message = message
# 在某个函数中引发自定义异常def example_function(x): if x < 0: raise CustomException("输入不能为负数！")
# 使用try-except语句捕获自定义异常try: example_function(-5)except CustomException as e: print("捕获到自定义异常：", e.message)
复制代码
这样就定义了一个名为CustomException的自定义异常类。
我们可以在程序中使用这个自定义异常来表示特定类型的错误，并根据需要在try-except语句中捕获和处理这些异常。
自定义异常的主要优势在于它能够使程序结构更清晰，能够更准确地表示程序中可能发生的异常情况，并能够根据具体情况提供更详细的错误信息。
异常处理的层次结构
与python异常相关的关键字主要有：
异常处理的层次结构如下：
try: # 可能引发异常的代码块 result = 1 / 0except ZeroDivisionError as e: # 处理特定异常 print(f"Error: {e}")except Exception as e: # 处理其他异常 print(f"Unexpected error: {e}")else: # 如果没有异常发生且try中没有return时执行的代码 print("No exceptions occurred.")finally: # 无论是否发生异常都会执行的代码 print("Finally block.")
复制代码
finally块中的代码无论是否引发异常都会执行。通常用于确保资源的释放或清理操作。
如何捕获多个异常？
在Python中，我们可以使用多个except分别捕获不同类型的异常。
try: # 一些可能会引发异常的操作 file = open('filename.txt', 'r') result = 10 / 0 # 这会引发一个 ZeroDivisionErrorexcept FileNotFoundError as e: print(f"文件未找到错误: {e}")except ZeroDivisionError as e: print(f"除以零错误: {e}")
复制代码
在这个例子中，我们使用了两个except块，分别来捕获FileNotFoundError和ZeroDivisionError这两种不同类型的异常。当try块中的代码抛出任一种异常时，对应类型的except块就会捕获并处理该异常。
另一种方法是通过元组的方式一次性捕获多个异常类型。
try: # 一些可能会引发异常的操作 file = open('filename.txt', 'r') result = 10 / 0 # 这会引发一个 ZeroDivisionErrorexcept (FileNotFoundError, ZeroDivisionError) as e: print(f"发生错误: {e}")
复制代码
在这个例子中，我们将多个异常类型放在一个元组中作为一个捕获异常的参数，这样就可以在一个except块中捕获多种类型的异常。
无论是逐个指定except块，还是使用一个元组指定多个异常类型，都可以帮助我们清晰地捕获并处理不同类型的异常。
异常的抛出
有些时候，我们可能需要主动抛出异常，比如：
在Python中，要手动抛出异常，可以使用raise语句。
def divide(x, y): if y == 0: raise ZeroDivisionError("除数不能为 0") return x / y
try: result = divide(10, 0) print(result)except ZeroDivisionError as e: print(f"发生除以零错误：{e}")
复制代码
在这个例子中，divide函数用于计算两个数相除，如果除数为0，则抛出一个ZeroDivisionError异常。在try块中调用了divide函数，并在except块中捕获了ZeroDivisionError异常。当除数为0时，divide函数会抛出异常，并且在except块中的代码会被执行。
通过raise语句，我们可以手动引发特定类型的异常，将其传播到调用栈中，并在需要的地方进行捕获和处理。
自定义异常
自定义异常通常被用于特定的情况或者错误类型，以便能够更清晰地识别和处理特定类型的问题。
以下是一个简单的自定义异常的示例：
class CustomException(Exception): def __init__(self, message="这是一个自定义异常"): self.message = message super().__init__(self.message)
复制代码
在这个例子中，我们创建了一个名为CustomException的自定义异常类，它继承自Python的内置异常类Exception。我们定义了它的__init__方法来初始化异常的消息，并调用了父类的__init__方法以设置异常消息。
接下来，我们可以使用这个自定义异常类来抛出异常，并在需要捕获它的地方进行处理：
def some_function(x): if x < 0: raise CustomException("输入不能为负数")
try: some_function(-1)except CustomException as e: print(f"捕获到了自定义异常：{e}")
复制代码
在这个示例中，some_function函数根据输入的值是否小于0来抛出我们定义的CustomException自定义异常。在try...except块中，我们捕获并处理了这个自定义异常。
通过创建自定义异常类，您可以更好地组织和标识程序中特定类型的错误，从而实现更清晰、更易于维护的异常处理机制。
异常处理(函数)：碰到 return 我该如何
a. 无 return 时
from loguru import logger
def example_function(raise_error=True): try: logger.debug("在try语句块中") if raise_error: raise ValueError("主动抛出一个异常...") # return 1 except: logger.error("在except语句块中") # return 2 else: logger.debug("在else语句块中") finally: logger.debug("在finally语句块中") # return 3
example_function()example_function(raise_error=False)
复制代码
这个比较清晰，也比较容易理解。
我们看到：
b. 仅 finally 里面无 return，无异常或有异常时
from loguru import logger
def example_function(raise_error=True): try: logger.debug("在try语句块中") if raise_error: raise IndexError("索引错误") return 1 except: logger.debug("在except语句块中") return 2 else: logger.debug("在else语句块中") return 2.5
finally: logger.debug("在finally语句块中") # return 3
result = example_function()logger.debug(f"result: {result}")
result2 = example_function(raise_error=False) # 不会执行except语句块logger.debug(f"result2: {result2}")
复制代码
这个我们可能第一感觉是会直接报错，其实不然。不过pycharm中确实飘红了~
然后我们执行，我们看到这种情况下else中的逻辑如意想的一样，并不会执行：
这个 else 真的好“鸡肋”啊。
c. 都有 return，无异常或有异常时
from loguru import logger
def example_function(raise_error=True): try: logger.debug("在try语句块中") if raise_error: raise IndexError("索引错误") return 1 except: logger.debug("在except语句块中") return 2 else: logger.debug("在else语句块中") return 2.5
finally: logger.debug("在finally语句块中") return 3
result = example_function()logger.debug(f"result: {result}")
result2 = example_function(raise_error=False) # 不会执行except语句块logger.debug(f"result2: {result2}")
复制代码
可以看到，无论是否异常，也都不会执行else中的逻辑~
有异常或无异常时，分别走完try或except中的逻辑，最终都会执行finally中的逻辑，并且因为finally中存在return，返回值为finally的return结果。
d. 只有 else 中有 return 时
from loguru import logger
def example_function(raise_error=True): try: logger.debug("在try语句块中") if raise_error: raise IndexError("索引错误") # return 1 except: logger.debug("在except语句块中") # return 2 else: logger.debug("在else语句块中") return 2.5
finally: logger.debug("在finally语句块中") # return 3
result = example_function()logger.debug(f"result: {result}")
result2 = example_function(raise_error=False) logger.debug(f"result2: {result2}")
复制代码
e. 只有 else 和 finally 中有 return 时
#!usr/bin/env python# -*- coding:utf-8 _*-# __author__：lianhaifeng# __time__：2024/3/28 23:29from loguru import logger
def example_function(raise_error=True): try: logger.debug("在try语句块中") if raise_error: raise IndexError("索引错误") # return 1 except: logger.debug("在except语句块中") # return 2 else: logger.debug("在else语句块中") return 2.5
finally: logger.debug("在finally语句块中") return 3
result = example_function()logger.debug(f"result: {result}")
result2 = example_function(raise_error=False) # 不会执行except语句块logger.debug(f"result2: {result2}")
复制代码
警告警告：请尽量避免在finally中return!
异常处理的最佳实践
只做精准捕获异常
这样可以防止隐藏其他问题，并使代码更具可读性。
file = Nonetry: file = open('hello.py', 'rb') content = file.read() # 这里可以有其他可能引发异常的操作except FileNotFoundError: print("文件未找到异常！")except PermissionError: print("权限异常！")except Exception as e: print("发生了一个异常:", e)finally: if file is not None: file.close()
复制代码
异常信息的记录
在处理异常时，最好记录异常的信息以便后续排查问题。可以使用标准库中的logging、traceback模块或第三方库如：loguru。
import loggingimport tracebackfrom loguru import logger
try: # 代码块 1 / 0except Exception as e: traceback.print_exc() logging.exception("发生了异常：%s", e) logger.error(f"发生了异常：{e}") logger.exception(f"发生了异常：{e}")
复制代码
慎用或不用 else，避免在 finally 里 return
在一些情况下，else可以被完全避免，通过在try块中放置需要运行成功的代码，以避免引入不必要的逻辑复杂度。
在finally中使用return可能使代码变得难以维护。由于finally中的代码总是会执行，因此使用return可能会导致不符合预期的行为，降低代码的可维护性。
异常链的传递(raise...from)
异常链传递指的是当一个异常捕获并处理后，可以选择重新引发（re-raise）同一个异常或者另一个异常，并且保留原始异常的信息。
这种做法可以保留异常的上下文信息，使得调试和排查问题更加方便。
在Python中，可以通过在异常处理程序中使用raise ... from语句来实现异常链的传递。例如，可以在捕获到某个异常后，重新引发同一个异常或者包装成新的异常并引发。
以下是一个示例，演示了异常链的传递：
try: # 可能会引发异常的代码 x = 10 / 0except ZeroDivisionError as original_exception: # 捕获并处理异常 # 引发新的异常，保留原始异常的信息 raise ValueError("除数不能为零") from original_exception
复制代码
在上面的代码中，原始的ZeroDivisionError异常被捕获，并且使用raise ... from语句重新引发成ValueError异常，同时保留了原始异常的信息。这样做的好处是，即使异常被重新引发了，我们仍然可以通过异常链追踪到原始异常的信息，从而更好地理解异常的发生原因。
自定义异常（主动抛出异常 raise）
在Python中，自定义异常类通常是通过继承内置的Exception类或其子类来创建的。
通过自定义异常类，我们可以为特定的错误情况提供更具有描述性和语义化的异常类型，从而更好地组织和处理异常情况。
class CustomException(Exception): def __init__(self, message): self.message = message
def __str__(self): return self.message
def divide(a, b): if b == 0: raise CustomException("除数不能为零") return a / b
# 使用自定义异常try: result = divide(10, 0)except CustomException as e: print("捕获到自定义异常：", e)
复制代码
在上面的示例中，我们创建了一个名为CustomException的自定义异常类，它继承自内置的Exception类。在异常类中，我们定义了__init__方法来初始化异常对象，并传入一个错误信息。另外，我们还重写了__str__方法，以便在打印异常对象时输出错误信息。
在divide函数中，我们检查除数是否为零，如果除数为零，则抛出自定义的CustomException异常，并传入相应的错误信息。在异常处理块中，我们捕获并处理自定义异常，并打印出异常信息。
通过自定义异常，我们可以更好地组织和处理程序中可能出现的特定错误情况，提高了代码的可读性和可维护性。同时，它也使得程序的错误处理更加灵活和精确。
借助上下文管理器处理异常
异常处理不应该喧宾夺主!
上下文管理器是一种与with语句协同工作的特殊Python对象，它能够极大地简化异常处理流程，提升代码的优雅性和可读性。
我们来看一下python工匠里的例子：
def upload_avatar(request): """用户上传新头像""" try: avatar_file = request.FILES['avatar'] except KeyError: raise error_codes.AVATAR_FILE_NOT_PROVIDED
try: resized_avatar_file = resize_avatar(avatar_file) except FileTooLargeError as e: raise error_codes.AVATAR_FILE_TOO_LARGE except ResizeAvatarError as e: raise error_codes.AVATAR_FILE_INVALID
try: request.user.avatar = resized_avatar_file request.user.save() except Exception: raise error_codes.INTERNAL_SERVER_ERROR return HttpResponse({})
复制代码
类似代码在座的各位肯定没少写~
这是一个处理用户上传头像的视图函数。这个函数内做了三件事情，并且针对每件事都做了异常捕获。如果做某件事时发生了异常，就返回对用户友好的错误到前端。
这样处理无可厚非，只是大量的try-except在主处理流程里使得我们一时间很难提炼出代码的核心逻辑，也不够pythonic。
利用上下文管理器就能够使得我们的代码更加清晰可读，具体操作是：
class raise_api_error: """captures specified exception and raise ApiErrorCode instead
:raises: AttributeError if code_name is not valid """ def __init__(self, captures, code_name): self.captures = captures self.code = getattr(error_codes, code_name)
def __enter__(self): # 该方法将在进入上下文时调用 return self
def __exit__(self, exc_type, exc_val, exc_tb): # 该方法将在退出上下文时调用 # exc_type, exc_val, exc_tb 分别表示该上下文内抛出的 # 异常类型、异常值、错误栈 if exc_type is None: return False
if exc_type == self.captures: raise self.code from exc_val return False
复制代码
接口的主要逻辑就变成下面这样：
def upload_avatar(request): """用户上传新头像""" with raise_api_error(KeyError, 'AVATAR_FILE_NOT_PROVIDED'): avatar_file = request.FILES['avatar']
with raise_api_error(ResizeAvatarError, 'AVATAR_FILE_INVALID'),\ raise_api_error(FileTooLargeError, 'AVATAR_FILE_TOO_LARGE'): resized_avatar_file = resize_avatar(avatar_file)
with raise_api_error(Exception, 'INTERNAL_SERVER_ERROR'): request.user.avatar = resized_avatar_file request.user.save() return HttpResponse({})
复制代码
简单明了了不少。
contextlib模块也提供了一些工具，用于支持与上下文管理器相关的操作。虽然contextlib模块本身并不直接用于异常处理，但它提供了一些用于创建上下文管理器的实用程序，这些上下文管理器可以帮助简化异常处理。
我们使用contextlib.contextmanager装饰器来创建一个简单的上下文管理器，用于捕获特定类型的异常：
import contextlibfrom loguru import logger
@contextlib.contextmanagerdef handle_file_exceptions(): try: yield except FileNotFoundError as e: logger.exception(f"File not found error: {e}") except PermissionError as e: logger.exception(f"Permission error: {e}")
# 使用上下文管理器with handle_file_exceptions(): with open('nonexistent_file.txt', 'r') as file: content = file.read()
复制代码
在这个例子中，handle_file_exceptions函数使用contextlib.contextmanager装饰器转变为一个上下文管理器。在调用yield之前的代码段被看作是上下文管理器的__enter__方法，在yield之后的代码段被看作是上下文管理器的__exit__方法。在__exit__方法中，我们捕获了FileNotFoundError和PermissionError，并打印了相应的错误信息。
虽然contextlib模块的主要目的是创建上下文管理器，但它也可以与异常处理一起使用，使得在特定上下文情境中进行异常处理变得更加方便和简洁。
使用装饰器处理异常
异常处理装饰器是另一种用于简化异常处理逻辑的技术，它可以在函数调用时自动捕获并处理异常，从而减少重复代码量，提高代码的可维护性和可读性。
from loguru import logger
def handle_exception(exception_handler): def decorator(func): def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except Exception as e: return exception_handler(e, *args, **kwargs)
return wrapper
return decorator
# 自定义异常处理函数def custom_exception_handler(exception, *args, **kwargs): # 这里可以进行自定义的异常处理逻辑 if isinstance(exception, ZeroDivisionError): logger.error(f"捕获到异常：{exception}")
return None # 返回处理结果或者 None
# 使用异常处理装饰器@handle_exception(custom_exception_handler)def divide(a, b): return a / b
result = divide(10, 1)logger.info(f"result: {result}")# 调用带有异常处理装饰器的函数result2 = divide(10, 0)logger.info(f"result2: {result2}")
复制代码
使用异常处理装饰器可以使代码更加简洁、清晰，并且能够提高代码的复用性和可维护性。注意: 异常处理装饰器的具体实现可以根据实际需求进行定制和扩展，以满足不同场景的需求。
from functools import wrapsfrom typing import Callable, Dict, Typefrom loguru import logger
class TryDecorator: def __init__(self): self.exception_handlers: Dict[Type[Exception], Callable] = {}
def try_(self, func: Callable) -> Callable: @wraps(func) def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except Exception as e: handler = self.get_exception_handler(type(e)) if handler is None: raise e return handler(func, e, *args, **kwargs)
return wrapper
def except_(self, *exceptions: Type[Exception]) -> Callable: def decorator(handler: Callable) -> Callable: for exception in exceptions: self.exception_handlers[exception] = handler return handler
return decorator
def get_exception_handler(self, exception_type: Type[Exception]) -> Callable: for exception, handler in self.exception_handlers.items(): if issubclass(exception_type, exception): return handler return lambda *args, **kwargs: None # 返回一个默认的异常处理函数，可以根据需要修改
try_decorator = TryDecorator()
@try_decorator.try_def my_function(): logger.info(1 / 0) logger.info('hello world')
@try_decorator.try_def my_function2(): raise IndexError("主动抛出了IndexError")
@try_decorator.except_(ZeroDivisionError)def handle_zero_division_error(func: Callable, exception: Exception, *args, **kwargs): logger.error(f"ZeroDivisionError in function {func.__name__}: {exception}")
@try_decorator.except_(IndexError)def handle_zero_division_error(func: Callable, exception: Exception, *args, **kwargs): logger.error(f"IndexError in function {func.__name__}: {exception}")
if __name__ == '__main__': my_function() my_function2()
复制代码
让你的函数返回一些有意义的、有类型的、安全的东西！
对于python函数的异常处理往往令我们比较的头疼。
比如，可能你的函数的正常流程是返回一个字符串，异常的时候是直接raise抛出呢还是返回一个特定值？这是一个问题！
传统的异常处理机制依赖于在函数内部抛出异常，然后在调用函数的地方进行捕获和处理。这种方式可能会导致代码分散、难以维护，同时将错误处理的责任分散到多个地方。异常可能会中断程序的正常流程，使得代码复杂和难以预测。
聪明如你，可能自己封装一个统一的结构化响应。
统一响应：谁弄（异）哭（常）的，谁就要负责哄（包装）~
不过我要告诉你的是，使用returns模块可以将函数的结果值进行封装，这样就可以更灵活地处理异常情况。
returns模块提供了Success和Failure两种类型，分别代表函数成功执行和出现错误。这就使得函数返回的结果更加明确，可以更容易地进行组合、转换和处理。
安装：
我们改写下使用装饰器处理异常部分的示例代码：
from typing import Callablefrom returns.result import Success, Failure, Resultfrom loguru import loggerfrom functools import wraps
class TryDecorator: def __init__(self): # 初始化异常处理程序字典 self.exception_handlers = {}
def try_(self, func: Callable) -> Callable[..., Result]: @wraps(func) def wrapper(*args, **kwargs) -> Result: try: result = func(*args, **kwargs) # 如果返回结果已经是 Result 类型，则直接返回 if isinstance(result, Result): return result # 否则将返回结果包装成 Success 类型 return Success(result) except Exception as e: # 获取对应异常类型的处理函数 handler = self.get_exception_handler(type(e)) if handler is None: # 如果没有找到对应的异常处理函数，则直接返回 Failure return Failure(e) # 调用对应异常处理函数处理异常 return handler(func, e, *args, **kwargs)
return wrapper
def except_(self, *exceptions: type) -> Callable: def decorator(handler: Callable) -> Callable: # 为每个异常类型关联对应的处理函数 for exception in exceptions: self.exception_handlers[exception] = handler return handler
return decorator
def get_exception_handler(self, exception_type: type) -> Callable: # 获取对应异常类型的处理函数 for exception, handler in self.exception_handlers.items(): if issubclass(exception_type, exception): return handler # 如果没有找到对应异常的处理函数，则返回一个默认的异常处理函数，可以根据需要修改 return lambda *args, **kwargs: None
try_decorator = TryDecorator()
@try_decorator.except_(ZeroDivisionError)def handle_zero_division_error(func: Callable, exception: Exception, *args, **kwargs) -> Result: # 处理 ZeroDivisionError 异常，并返回 Failure logger.error(f"ZeroDivisionError in function {func.__name__}: {exception}") return Failure(exception)
@try_decorator.except_(IndexError)def handle_index_error(func: Callable, exception: Exception, *args, **kwargs) -> Result: # 处理 IndexError 异常，并返回 Failure logger.error(f"IndexError in function {func.__name__}: {exception}") return Failure(exception)
@try_decorator.try_def my_function(a, b): return Success(a / b)
@try_decorator.try_def my_function2(): raise IndexError("主动抛出了IndexError")
if __name__ == '__main__': # 测试 try_decorator 的 try_ 方法 # result1 = try_decorator.try_(my_function)(10, 1) result1 = my_function(10, 1) if isinstance(result1, Success): logger.info(f"没有异常：{result1}， result1: {result1.unwrap()}")
# 测试 ZeroDivisionError 异常处理 result2 = my_function(10, 0) if isinstance(result2, Failure): logger.info(f"发生异常：{result2}， result2: {result2.failure()}")
result3 = my_function2() if isinstance(result3, Failure): logger.error(f"Failed with: {result3.failure()}")
复制代码
是不是清爽了许多，输出结果为：
更多returns特性请阅读：github: github.com/dry-python/…
更多场景举例
只做示例介绍，不一定遵循最佳实践。
基本的异常处理重试装饰器
下面是一个基本的异常处理重试装饰器的示例：
import timefrom functools import wrapsfrom typing import Callable
def retry_on_exception(max_retries: int, delay: float = 0.1): def decorator(func: Callable): @wraps(func) def wrapper(*args, **kwargs): for _ in range(max_retries): try: return func(*args, **kwargs) except Exception as e: print(f"Exception caught: {e}. Retrying...") time.sleep(delay) raise Exception(f"Failed after {max_retries} retries")
return wrapper
return decorator
# 使用示例@retry_on_exception(max_retries=3)def potentially_unstable_function(): import random if random.randint(1, 10) < 8: raise ValueError("Random error") else: return "Success"
if __name__ == "__main__": result = potentially_unstable_function() print(result)
复制代码
在这个示例中，retry_on_exception是一个装饰器工厂函数，它接受最大重试次数和延迟作为参数。它返回一个装饰器，该装饰器会捕获被装饰函数可能抛出的异常，并在遇到异常时进行重试。
被装饰的函数potentially_unstable_function可能会抛出随机异常。我们使用retry_on_exception装饰器装饰它，以便在遇到异常时进行重试，最多重试三次。
你可以根据需要调整max_retries和delay参数来控制重试的次数和重试之间的延迟。
异常优雅重试
其实，很多轮子已经是卷中卷了，我们大可使用优雅的retrying模块。
使用也很简单：
from retrying import retryimport randomfrom loguru import logger
attempt = 0
# 重试装饰器@retry(stop_max_attempt_number=3, wait_fixed=100) # 最多重试3次，每次间隔100msdef potentially_unstable_function(): global attempt attempt += 1 if random.randint(1, 10) < 8: logger.error(attempt) raise ValueError("Random error") else: return "Success"
if __name__ == "__main__": result = potentially_unstable_function() logger.info(result)
复制代码
这里为了演示确实最大重试了stop_max_attempt_number=3，加了attempt，不然代码只会更少！
超过3次时报错如下：
总结
恭喜毕业！异常处理是编写稳健、可维护 Python 代码的重要组成部分。以下是异常处理的关键点总结：
捕获最具体的异常：为了更好地理解和处理错误，请捕获最具体的异常类型。
不要使用单独的except处理所有异常：避免使用空的except块，因为它们会捕获所有异常，包括意外的情况，会增加调试的困难。
谨慎使用else和finally块：else块用于在没有异常时执行特定代码，finally块用于确保资源释放或清理操作。
记录异常信息：捕获异常后，通常应记录异常信息，以便诊断和修复问题。
合理使用自定义异常： 当您的应用程序遇到特定异常条件时，建议创建一个自定义异常类，可以更清晰地表达和有效处理这些情况。
避免不必要的异常处理：不应将异常处理用于预期的控制流，而应只在真正可能发生异常的地方使用它。
使用装饰器，上下文管理器，returns库使你的异常处理更加的pythonic。
作者：暴走的海鸽
链接：https://juejin.cn/post/7368741477214011402
来源：稀土掘金
评论