Python异常处理else和finally清理资源实战

脚本专家

在 Python 中，try 异常处理结构并不只有 try 和 except，完整形式包括 try、except、else、finally 四个子句。多数脚本只使用前两个，但 else 能把成功路径从 try 中分离出来，finally 能保证资源清理一定执行。下面按执行顺序、代码实现和典型场景说明。

一、完整结构与执行顺序

2. try:
3.     result = perform_operation()
4. except SomeError:
5.     handle_error()
6. else:
7.     process_result(result)
8. finally:
9.     cleanup()

复制代码

try 总是先执行；except 只在 try 抛出匹配异常时执行；else 只在 try 无异常时执行；finally 无论是否异常、异常是否被捕获都执行。这个顺序决定了 else 和 finally 的用途。

二、else：把成功路径放到 try 外
else 的代码不在 try 保护范围内，因此它抛出的异常不会被前面的 except 捕获。推荐把可能出错的 open 和正常处理逻辑 upper 分开，避免处理逻辑 bug 被 FileNotFoundError 错误捕获。

2. def load_and_process(filepath):
3.     try:
4.         data = open(filepath, 'r').read()
5.     except FileNotFoundError:
6.         print(f'文件不存在: {filepath}')
7.         return None
8.     else:
9.         print('文件读取成功，开始处理...')
10.         processed = data.upper()
11.         return processed

复制代码

对比把处理逻辑一并放入 try 的写法：

2. def load_and_process_bad(filepath):
3.     try:
4.         data = open(filepath, 'r').read()
5.         processed = data.upper()
6.         return processed
7.     except FileNotFoundError:
8.         print(f'文件不存在: {filepath}')
9.         return None

复制代码

这种方式会把 upper 等处理逻辑的异常也归入 FileNotFoundError 的处理语境，不利于定位问题。

典型场景一：数据库查询

2. def query_database(connection, query):
3.     try:
4.         cursor = connection.cursor()
5.         cursor.execute(query)
6.     except DatabaseError as e:
7.         print(f'查询失败: {e}')
8.         return []
9.     else:
10.         results = cursor.fetchall()
11.         return results

复制代码

典型场景二：API 调用

2. def fetch_user_data(user_id):
3.     try:
4.         response = requests.get(f'/api/users/{user_id}', timeout=5)
5.         response.raise_for_status()
6.     except requests.RequestException as e:
7.         print(f'请求失败: {e}')
8.         return None
9.     else:
10.         return response.json()

复制代码

典型场景三：输入验证

2. def get_positive_number(prompt):
3.     try:
4.         value = int(input(prompt))
5.     except ValueError:
6.         print('请输入有效的整数')
7.         return None
8.     else:
9.         if value <= 0:
10.             print('请输入正数')
11.             return None
12.         return value

复制代码

三、finally：无论如何都执行
finally 的核心规则是：无论是否发生异常、异常是否被捕获，都会执行；即使 try 或 except 中有 return，finally 也会执行。注意 finally 中写 return 会覆盖之前的 return，不建议这样用。

2. def test_finally(scenario):
3.     try:
4.         print('try开始')
5.         if scenario == 'error':
6.             raise ValueError('测试异常')
7.         if scenario == 'success':
8.             print('try正常完成')
9.             return f'结果: {scenario}'
10.     except ValueError:
11.         print('except捕获了异常')
12.         return '异常结果'
13.     finally:
14.         print('finally执行了！')
16. print('场景1: 正常')
17. result1 = test_finally('success')
18. print(f'返回值: {result1}')
19. print('场景2: 异常')
20. result2 = test_finally('error')
21. print(f'返回值: {result2}')

复制代码

2. def bad_finally():
3.     try:
4.         return 'try中的return'
5.     finally:
6.         return 'finally中的return'
8. print(bad_finally())

复制代码

bad_finally 会输出 finally中的return，说明 finally 的 return 覆盖了 try 的 return。

资源清理是 finally 最常见的用途。文件操作示例：

2. def read_file_with_finally(filepath):
3.     f = None
4.     try:
5.         f = open(filepath, 'r', encoding='utf-8')
6.         return f.read()
7.     except FileNotFoundError:
8.         print(f'文件不存在: {filepath}')
9.         return None
10.     finally:
11.         if f:
12.             f.close()
13.             print('文件已关闭')

复制代码

线程锁释放示例：

2. import threading
4. class ThreadSafeCounter:
5.     def __init__(self):
6.         self._lock = threading.Lock()
7.         self._value = 0
9.     def increment(self):
10.         self._lock.acquire()
11.         try:
12.             self._value += 1
13.             return self._value
14.         finally:
15.             self._lock.release()

复制代码

临时文件清理示例：

2. import os
4. def process_with_temp_file(data):
5.     temp_path = 'temp_processing.txt'
6.     try:
7.         with open(temp_path, 'w') as f:
8.             f.write(data)
9.         return os.path.getsize(temp_path)
10.     finally:
11.         if os.path.exists(temp_path):
12.             os.remove(temp_path)
13.             print('临时文件已清理')

复制代码

四、try-except-else-finally 组合实战
数据库事务是典型组合场景：try 中执行多条 SQL，异常时 rollback，成功时在 else 中 commit，finally 关闭游标。

2. def transfer_money(conn, from_id, to_id, amount):
3.     try:
4.         cursor = conn.cursor()
5.         cursor.execute('BEGIN TRANSACTION')
6.         cursor.execute(
7.             'UPDATE accounts SET balance = balance - ? WHERE id = ?',
8.             (amount, from_id)
9.         )
10.         cursor.execute(
11.             'UPDATE accounts SET balance = balance + ? WHERE id = ?',
12.             (amount, to_id)
13.         )
14.         cursor.execute('SELECT balance FROM accounts WHERE id = ?', (from_id,))
15.         if cursor.fetchone()[0] < 0:
16.             raise ValueError('余额不足')
17.     except ValueError as e:
18.         print(f'业务错误: {e}')
19.         conn.rollback()
20.         return False
21.     except Exception as e:
22.         print(f'数据库错误: {e}')
23.         conn.rollback()
24.         return False
25.     else:
26.         conn.commit()
27.         print('转账成功')
28.         return True
29.     finally:
30.         cursor.close()

复制代码

这里 else 只在所有 SQL 执行且余额检查通过后提交事务；任何异常进入 except 回滚；finally 关闭游标。

计时和日志装饰器也能体现完整结构：except 中记录失败耗时并重新抛出，else 中记录成功耗时并返回结果，finally 可用于统一收尾。

2. import time
3. import logging
5. def timed_operation(operation_name):
6.     def decorator(func):
7.         def wrapper(*args, **kwargs):
8.             start = time.perf_counter()
9.             try:
10.                 result = func(*args, **kwargs)
11.             except Exception as e:
12.                 elapsed = time.perf_counter() - start
13.                 logging.error(
14.                     f'{operation_name} 失败 '
15.                     f'(耗时{elapsed:.3f}秒): {e}'
16.                 )
17.                 raise
18.             else:
19.                 elapsed = time.perf_counter() - start
20.                 logging.info(
21.                     f'{operation_name} 成功 '
22.                     f'(耗时{elapsed:.3f}秒)'
23.                 )
24.                 return result
25.             finally:
26.                 pass
27.         return wrapper
28.     return decorator
30. @timed_operation('数据处理')
31. def process_large_dataset(data):
32.     time.sleep(0.5)
33.     return len(data)
35. result = process_large_dataset([1, 2, 3])

复制代码

五、总结与选型
在 Python 异常处理中，try-except-else-finally 是完整工具。else 让成功路径清晰，finally 让资源清理可靠。各子句作用可归纳为：try 总是首先执行，放可能出错的代码；except 在 try 中发生异常时执行，处理已知异常；else 在 try 中没有异常时执行，处理成功结果；finally 无论如何都执行，清理资源，如关闭文件、释放锁等。
最佳实践是：with 语句可以替代大多数 finally 场景，例如文件、锁等；只有在 with 不够用时才手写 finally。