Python 中的异常处理机制是怎样的？ - 面试题

异常的基本概念

异常是程序在运行过程中发生的错误或异常情况。Python 使用异常处理机制来优雅地处理这些错误，避免程序崩溃。

异常的类型

python
# 常见异常类型
print(1 / 0)  # ZeroDivisionError: division by zero

print(int("abc"))  # ValueError: invalid literal for int() with base 10: 'abc'

print(my_variable)  # NameError: name 'my_variable' is not defined

print([1, 2, 3][10])  # IndexError: list index out of range

print({"name": "Alice"}["age"])  # KeyError: 'age'

open("nonexistent.txt")  # FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent.txt'

try-except 语句

基本语法

python
try:
    # 可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常
    print("除数不能为零")
except Exception as e:
    # 处理其他异常
    print(f"发生异常: {e}")
else:
    # 没有异常时执行
    print("计算成功")
finally:
    # 无论是否异常都执行
    print("执行完毕")

捕获多个异常

python
try:
    user_input = input("请输入一个数字: ")
    number = int(user_input)
    result = 100 / number
except ValueError:
    print("请输入有效的数字")
except ZeroDivisionError:
    print("除数不能为零")
except (ValueError, ZeroDivisionError) as e:
    print(f"发生错误: {e}")

捕获所有异常

python
try:
    result = 10 / 0
except Exception as e:
    print(f"捕获到异常: {type(e).__name__}: {e}")

异常的传播

异常向上传播

python
def function_a():
    function_b()

def function_b():
    function_c()

def function_c():
    raise ValueError("这是一个错误")

try:
    function_a()
except ValueError as e:
    print(f"在 function_a 中捕获异常: {e}")

重新抛出异常

python
def process_data(data):
    try:
        result = int(data)
    except ValueError:
        print("数据转换失败")
        raise  # 重新抛出异常

try:
    process_data("abc")
except ValueError:
    print("主程序捕获到异常")

异常链

python
def read_config():
    try:
        with open("config.txt") as f:
            return f.read()
    except FileNotFoundError as e:
        raise RuntimeError("配置文件不存在") from e

try:
    read_config()
except RuntimeError as e:
    print(f"错误: {e}")
    print(f"原始异常: {e.__cause__}")

自定义异常

创建自定义异常类

python
class CustomError(Exception):
    """自定义异常基类"""
    pass

class ValidationError(CustomError):
    """验证错误"""
    def __init__(self, message, field=None):
        self.field = field
        super().__init__(message)

class NotFoundError(CustomError):
    """未找到错误"""
    pass

def validate_user_data(data):
    if not data.get("name"):
        raise ValidationError("姓名不能为空", field="name")
    if not data.get("email"):
        raise ValidationError("邮箱不能为空", field="email")
    if "@" not in data.get("email", ""):
        raise ValidationError("邮箱格式不正确", field="email")

try:
    validate_user_data({"name": "Alice"})
except ValidationError as e:
    print(f"验证失败: {e}, 字段: {e.field}")

异常的属性和方法

python
class DatabaseError(Exception):
    def __init__(self, message, error_code=None, query=None):
        self.error_code = error_code
        self.query = query
        super().__init__(message)
    
    def get_details(self):
        return {
            "message": str(self),
            "error_code": self.error_code,
            "query": self.query
        }

try:
    raise DatabaseError(
        "数据库连接失败",
        error_code=500,
        query="SELECT * FROM users"
    )
except DatabaseError as e:
    print(f"错误信息: {e}")
    print(f"详细信息: {e.get_details()}")

上下文管理器与异常

with 语句

python
# 自动处理资源清理
with open("example.txt", "w") as f:
    f.write("Hello, World!")
    # 即使发生异常，文件也会自动关闭

# 自定义上下文管理器
class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        if exc_type:
            print(f"发生异常: {exc_val}")
        return False  # 不抑制异常

with FileManager("test.txt", "w") as f:
    f.write("Test content")
    # raise ValueError("测试异常")

contextlib 模块

python
from contextlib import contextmanager

@contextmanager
def file_manager(filename, mode):
    file = open(filename, mode)
    try:
        yield file
    finally:
        file.close()

with file_manager("test.txt", "w") as f:
    f.write("Hello")

# 使用 closing
from contextlib import closing

class Resource:
    def close(self):
        print("资源已关闭")

with closing(Resource()) as resource:
    print("使用资源")

异常处理的最佳实践

1. 具体化异常捕获

python
# 不好的做法 - 捕获所有异常
try:
    result = int(user_input)
except:
    pass

# 好的做法 - 捕获特定异常
try:
    result = int(user_input)
except ValueError:
    print("请输入有效的数字")

2. 提供有用的错误信息

python
# 不好的做法
try:
    result = 10 / 0
except ZeroDivisionError:
    print("错误")

# 好的做法
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"计算错误: 除数不能为零。详细信息: {e}")

3. 不要忽略异常

python
# 不好的做法 - 忽略异常
try:
    result = risky_operation()
except Exception:
    pass

# 好的做法 - 记录或处理异常
import logging

try:
    result = risky_operation()
except Exception as e:
    logging.error(f"操作失败: {e}")
    raise

4. 使用 finally 清理资源

python
def process_file(filename):
    file = None
    try:
        file = open(filename, 'r')
        data = file.read()
        return process_data(data)
    except IOError as e:
        print(f"文件操作错误: {e}")
    finally:
        if file:
            file.close()

5. 异常层次结构

python
class AppError(Exception):
    """应用程序错误基类"""
    pass

class DataError(AppError):
    """数据错误"""
    pass

class ValidationError(DataError):
    """验证错误"""
    pass

class NetworkError(AppError):
    """网络错误"""
    pass

def handle_error(error):
    if isinstance(error, ValidationError):
        print("验证失败")
    elif isinstance(error, DataError):
        print("数据错误")
    elif isinstance(error, NetworkError):
        print("网络错误")
    else:
        print("未知错误")

实际应用场景

1. 文件操作

python
def read_config_file(filename):
    try:
        with open(filename, 'r') as f:
            return json.load(f)
    except FileNotFoundError:
        raise ConfigError(f"配置文件不存在: {filename}")
    except json.JSONDecodeError as e:
        raise ConfigError(f"配置文件格式错误: {e}")
    except Exception as e:
        raise ConfigError(f"读取配置文件失败: {e}")

2. 数据库操作

python
def execute_query(query, params=None):
    try:
        connection = get_db_connection()
        cursor = connection.cursor()
        cursor.execute(query, params or ())
        return cursor.fetchall()
    except DatabaseError as e:
        logging.error(f"数据库查询失败: {e}")
        raise
    finally:
        if connection:
            connection.close()

3. API 调用

python
import requests

def fetch_data(url):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()  # 检查 HTTP 错误
        return response.json()
    except requests.exceptions.Timeout:
        raise APIError("请求超时")
    except requests.exceptions.HTTPError as e:
        raise APIError(f"HTTP 错误: {e.response.status_code}")
    except requests.exceptions.RequestException as e:
        raise APIError(f"请求失败: {e}")
    except json.JSONDecodeError:
        raise APIError("响应数据格式错误")

4. 数据验证

python
def validate_user(user_data):
    errors = []
    
    if not user_data.get("name"):
        errors.append("姓名不能为空")
    elif len(user_data["name"]) < 2:
        errors.append("姓名至少需要2个字符")
    
    if not user_data.get("email"):
        errors.append("邮箱不能为空")
    elif "@" not in user_data["email"]:
        errors.append("邮箱格式不正确")
    
    if errors:
        raise ValidationError("用户数据验证失败", errors=errors)
    
    return True

调试异常

使用 traceback 模块

python
import traceback

def risky_function():
    return 1 / 0

try:
    risky_function()
except Exception:
    print("发生异常:")
    traceback.print_exc()
    print("\n异常信息:")
    print(traceback.format_exc())

获取异常堆栈

python
import sys
import traceback

def function_a():
    function_b()

def function_b():
    function_c()

def function_c():
    raise ValueError("测试异常")

try:
    function_a()
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(f"异常类型: {exc_type}")
    print(f"异常值: {exc_value}")
    print("堆栈跟踪:")
    traceback.print_tb(exc_traceback)

异常处理性能考虑

python
# 异常处理的开销
import time

# 不好的做法 - 使用异常控制流程
def is_positive_with_exception(number):
    try:
        if number < 0:
            raise ValueError
        return True
    except ValueError:
        return False

# 好的做法 - 使用条件判断
def is_positive_with_condition(number):
    return number >= 0

# 性能测试
start = time.time()
for i in range(1000000):
    is_positive_with_exception(i)
print(f"异常处理方式: {time.time() - start:.4f} 秒")

start = time.time()
for i in range(1000000):
    is_positive_with_condition(i)
print(f"条件判断方式: {time.time() - start:.4f} 秒")

总结

Python 异常处理机制的关键点：

异常类型：理解不同类型的异常及其用途
try-except：捕获和处理异常的基本语法
异常传播：异常如何在调用栈中传播
自定义异常：创建特定领域的异常类
上下文管理器：使用 with 语句自动管理资源
最佳实践：具体化异常、提供有用信息、不忽略异常
实际应用：文件操作、数据库操作、API 调用等场景
调试技巧：使用 traceback 模块获取详细信息
性能考虑：避免使用异常控制正常流程

掌握异常处理机制，能够编写出健壮、可靠、易于维护的 Python 程序。