Python中异常处理的最佳实践：十个示例

原创叁歲伎倆 2025-03-05 02:57 20阅读 0赞

在 Python 中，异常处理是一种机制，用于检测和管理程序运行过程中的错误。以下是一些关于异常处理的优秀实践示例：

1. **使用 try/except 块**：
   ```python
   def divide_numbers(a, b):
       try:
           return a / b
       except ZeroDivisionError:
           print("Cannot divide by zero!")
           return None

result = divide_numbers(10, 5)
   if result is not None:
       print(result)
   ```
2. **明确异常类型**：
   ```python
   def validate_email(email):
       try:
           emailaddress = email.lower()
           # 检查常见的无效邮箱格式
           if '@' not in emailaddress or '.' not in emailaddress:
               raise ValueError("Invalid email format.")
           return email
       except ValueError as ve:
           print(ve)
           return None

email = "invalid_email@domain.com"
   validated_email = validate_email(email)
   if validated_email is not None:
       print(validated_email)
   ```
3. **使用 finally 块清理资源**：
   ```python
   def open_file(filename, mode):
       try:
           f = open(filename, mode))
           return f
       except FileNotFoundError:
           print(f"{filename} not found!"))
           return None
       finally:
           if 'f' in locals():  # check for 'f' in locals()
               f.close()  # close the file

filename = "example.txt"
   opened_file = open_file(filename, "r")
   if opened_file is not None:
       print(opened_file.read()))
   ```
4. **避免过度处理异常**：
   ```python
   def safe_division(a, b):
       try:
           result = a / b
           return result
       except ZeroDivisionError:
           # 返回一个有意义的值，如 -1
           return -1

division_result = safe_division(10, 5)
   print(division_result)  # 输出：2.0
   ```
5. **利用 logging 追踪错误**：
   ```python
   import logging

def setup_logger(filename, level=logging.INFO):
       logger = logging.getLogger(__name__)
       logger.setLevel(level)

handler = logging.FileHandler(filename)
       handler.setLevel(logging.DEBUG)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
       handler.setFormatter(formatter)

logger.addHandler(handler)
       return logger

filename = "error_log.txt"
   logger = setup_logger(filename, level=logging.ERROR)
   
   def some_function():
       # 模拟可能引发错误的代码
       nonexistent_attribute = some_object().nonexistent_attribute
       
   try:
       some_function()
       logger.info("Some function executed successfully.")
       with open(filename, "a")) as f:
           f.write("Execution success logged to file.\n")
       except Exception as e:
           # 记录错误日志
           logger.error(f"An error occurred during execution: {e}") )
           with open(filename, "a")) as f:
               f.write(f"{str(e)} - Error logging in file.\n") )
   finally:
       logger.removeHandler(handler)  # 关闭日志处理器

```
6. **避免全局异常处理**：
   ```python
   class MyClass:
       def some_method(self):
           # 模拟可能会抛出异常的代码
           try:
               result = do_something()
               return result
           except SomeException as se:
               self.handle_exception(se)
               return None

def handle_exception(self, exception):
           print(f"Handling error: {exception}")
           # 这里可以添加自定义错误处理逻辑

my_instance = MyClass()
   result = my_instance.some_method()
   if result is not None:
       print(result)
   ```
7. **使用局部异常处理**：
   ```python
   def divide_numbers(a, b):
       try:
           return a / b
       except ZeroDivisionError:
           # 这里是捕获到错误后执行的代码
           print("Cannot divide by zero!")
           return None

def some_function():
       a = 10
       b = 5
       
       result = divide_numbers(a, b)
       if result is not None:
           print(f"Result: {result}")

try:
       some_function()
   except Exception as e:
       print(f"An error occurred: {e}")
   ```
8. **使用 with 语句处理文件或资源**：
   ```python
   def open_and_read_file(filename):
       try:
           with open(filename, "r") as f:
               content = f.read()
               return content
       except FileNotFoundError:
           print(f"{filename} not found!"))
           return None

filename = "example.txt"
   file_content = open_and_read_file(filename)
   if file_content is not None:
       print(file_content)
   ```
9. **对异常进行分级处理**：
   ```python
   class CustomException(Exception):
       pass

class NormalException(Exception):
       pass

def some_function():
       try:
           # 正常业务逻辑代码
           pass
       except ZeroDivisionError as ze:
           # 处理特定的异常，这里为除零错误
           raise CustomException(f"Cannot divide by zero: {ze.__str__()}") from ze
       except NormalException as ne:
           # 可以对所有正常但需要处理的异常进行捕获并记录
           print(f"Caught normal exception: {ne.__str__()}}")
       finally:
           # 对所有类型的异常进行统一的清理操作，如关闭连接等
           pass

try:
       some_function()
   except Exception as e:
       print(f"Encountered an error: {e}}")
   ```
10. **结合日志和跟踪工具**：
    在处理复杂的系统或应用时，结合日志记录异常发生的时间、位置以及相关的上下文信息。同时，使用像 Sentry 这样的跟踪工具可以更好地帮助你定位问题的根源，并提供可能的解决方案。

```python
import logging
sentry_integration = # 假设已集成 Sentry

# 设置日志级别和输出路径
logging.basicConfig(level=logging.ERROR, filename="app_errors.log", filemode="w")

def handle_exception(exception, logger):
    try:
        # 在日志中记录异常信息
        logger.error(f"An error occurred: {exception.__str__()}"))
        
        # 将异常发送到 Sentry
        sentry_integration.capture exception
        
        # 再次尝试处理异常，这里假设重新抛出一个特定的异常
        raise ValueError("Failed to handle exception. Please check Sentry logs for more details.") from exception
    except Exception as e:
        # 如果在向上抛出异常的过程中又出现了新的异常，我们需要记录这个新出现的异常
        logger.error(f"An unexpected error occurred while handling the original exception: {e.__str__()}"))
        sentry_integration.capture exception

# 在需要处理异常的地方调用 handle_exception 函数
try:
    some_function()  # 假设在 some_function() 中发生了错误
except Exception as e:
    handle_exception(e, logging.getLogger(__name__))))  # 将捕获的异常传递给 handle_exception 函数处理

```
```