一、什么是上下文管理？
1.1 核心概念
上下文管理（Context Management） 是 Python 中管理资源生命周期的编程模式，它确保资源在使用后被正确释放。
1.2 资源生命周期模式
获取资源 → 使用资源 → 释放资源所有需要管理的资源都遵循这个模式：文件需要打开/关闭，网络连接需要建立/断开，锁需要获取/释放等。
二、为什么需要 with 语句？
2.1 传统方式的缺陷
python
# 容易出现问题的传统写法
file = open("data.txt", "r")
try:
data = file.read()
# 如果这里发生异常...
finally:
file.close() # 必须手动关闭问题：
- 容易忘记调用
close() - 代码冗长不优雅
- 异常处理复杂
2.2 with 语句的优势
python
# 使用 with 的优雅写法
with open("data.txt", "r") as file:
data = file.read()
# 自动关闭文件，无需手动操作优点：
- ✅ 自动资源管理
- ✅ 异常安全
- ✅ 代码简洁
- ✅ 可读性强
三、with 语句的基本用法
3.1 基础语法
python
with 上下文表达式 as 变量:
# 使用资源的代码块3.2 文件操作示例
python
# 读取文件
with open("example.txt", "r", encoding="utf-8") as file:
content = file.read()
# 文件自动关闭，即使发生异常
# 写入文件
with open("output.txt", "w", encoding="utf-8") as file:
file.write("Hello, World!")3.3 管理多个资源
python
# 同时管理多个文件
with open("input.txt", "r") as infile, \
open("output.txt", "w") as outfile:
outfile.write(infile.read().upper())
# 等效写法
with open("input.txt", "r") as infile:
with open("output.txt", "w") as outfile:
outfile.write(infile.read().upper())四、工作原理：上下文管理器协议
4.1 两个魔法方法
任何支持 with 语句的对象都必须实现这两个方法：
python
class MyContextManager:
def __enter__(self):
"""进入 with 代码块时调用"""
# 1. 获取资源
# 2. 返回资源对象
return self.resource
def __exit__(self, exc_type, exc_val, exc_tb):
"""退出 with 代码块时调用"""
# 1. 释放资源
# 2. 可选的异常处理
# exc_type: 异常类型，无异常时为 None
# exc_val: 异常值
# exc_tb: 异常追溯信息4.2 执行流程
python
# 实际执行顺序
manager = MyContextManager() # 创建管理器实例
resource = manager.__enter__() # 获取资源
try:
# 执行 with 块内的代码
use_resource(resource)
except Exception as e:
# 如果有异常，传递给 __exit__
manager.__exit__(type(e), e, e.__traceback__)
raise # 重新抛出异常
else:
# 没有异常，正常退出
manager.__exit__(None, None, None)五、创建自定义上下文管理器
5.1 类方式实现
python
class Timer:
"""计时器上下文管理器"""
def __enter__(self):
import time
self.start = time.time()
print("开始计时...")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
import time
self.end = time.time()
print(f"耗时: {self.end - self.start:.4f}秒")
# 返回 False 让异常继续传播
return False
# 使用
with Timer():
import time
time.sleep(1.5)5.2 使用 contextlib 模块
Python 提供了更简单的创建方式：
python
from contextlib import contextmanager
import time
@contextmanager
def timer(name="操作"):
"""使用生成器创建上下文管理器"""
start = time.time()
print(f"{name}开始...")
try:
yield # 在此处暂停，执行 with 块内的代码
finally:
end = time.time()
print(f"{name}结束，耗时: {end - start:.4f}秒")
# 使用
with timer("数据处理"):
time.sleep(1)
# 其他操作六、实际应用场景
6.1 数据库连接管理
python
import sqlite3
from contextlib import contextmanager
@contextmanager
def db_connection(db_path):
"""自动管理数据库连接"""
conn = sqlite3.connect(db_path)
try:
yield conn
finally:
conn.close()
# 使用
with db_connection('test.db') as conn:
cursor = conn.cursor()
cursor.execute('SELECT * FROM users')
results = cursor.fetchall()6.2 临时目录管理
python
import tempfile
import os
with tempfile.TemporaryDirectory() as temp_dir:
print(f"临时目录: {temp_dir}")
# 在临时目录中创建文件
temp_file = os.path.join(temp_dir, "temp.txt")
with open(temp_file, "w") as f:
f.write("临时内容")
# 使用临时文件...
# 退出 with 块后，临时目录自动删除6.3 线程锁管理
python
import threading
lock = threading.Lock()
shared_data = 0
def increment():
global shared_data
with lock: # 自动获取和释放锁
shared_data += 1
# 比手动管理更安全
def increment_manual():
global shared_data
lock.acquire()
try:
shared_data += 1
finally:
lock.release() # 容易忘记！6.4 临时修改配置
python
import sys
from contextlib import redirect_stdout
# 临时重定向输出
with open('output.log', 'w') as f:
with redirect_stdout(f):
print("这行会写入文件")
print("这行也会写入文件")
print("这行显示在屏幕上")七、高级用法
7.1 异常处理
python
class SafeOperation:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type is not None:
print(f"发生异常: {exc_type.__name__}: {exc_val}")
# 返回 True 表示异常已处理，不会向外传播
return True # 抑制异常
return False # 让异常继续传播
with SafeOperation():
raise ValueError("测试异常") # 这个异常会被抑制
print("程序继续执行")7.2 嵌套上下文管理器
python
class Indenter:
def __init__(self):
self.level = 0
def __enter__(self):
self.level += 1
return self
def __exit__(self, *args):
self.level -= 1
def print(self, text):
print(' ' * self.level + text)
# 使用
with Indenter() as indent:
indent.print("级别1")
with indent:
indent.print("级别2")
with indent:
indent.print("级别3")
indent.print("回到级别1")7.3 组合使用
python
from contextlib import ExitStack
def process_files(filenames):
"""同时打开多个文件，自动管理"""
with ExitStack() as stack:
files = [stack.enter_context(open(fname, 'r'))
for fname in filenames]
# 处理所有文件
for file in files:
print(file.read())
# 所有文件自动关闭八、常见内置上下文管理器
| 类型 | 示例 | 用途 |
|---|---|---|
| 文件 | open() |
文件I/O |
| 线程锁 | threading.Lock() |
线程同步 |
| 数据库 | sqlite3.connect() |
数据库连接 |
| 网络 | socket.create_connection() |
网络连接 |
| 临时文件 | tempfile 模块 |
临时文件/目录 |
| 重定向 | contextlib.redirect_stdout() |
输出重定向 |
九、最佳实践
9.1 文件操作规范
python
# 好：明确指定编码
with open("data.txt", "r", encoding="utf-8") as f:
data = f.read()
# 更好：使用 pathlib
from pathlib import Path
file_path = Path("data.txt")
with file_path.open("r", encoding="utf-8") as f:
data = f.read()9.2 错误处理建议
python
try:
with open("missing.txt", "r") as f:
data = f.read()
except FileNotFoundError:
print("文件不存在")
except IOError as e:
print(f"I/O错误: {e}")9.3 资源释放确认
python
class Resource:
def __enter__(self):
print("获取资源")
return self
def __exit__(self, *args):
print("释放资源") # 确保这里被调用
def use(self):
print("使用资源")
with Resource() as r:
r.use()
raise Exception("测试异常")
# 即使有异常，__exit__ 也会被调用十、总结
关键要点：
with语句是 Python 管理资源的首选方式- 确保资源总是被正确释放，即使发生异常
- 减少样板代码，提高可读性
- 遵循上下文管理器协议 （
__enter__/__exit__） - 优先使用内置上下文管理器，必要时创建自定义
黄金法则：
python
# 当你需要 "打开-使用-关闭" 模式时：
# ❌ 不要这样做：
resource = acquire_resource()
try:
use_resource(resource)
finally:
release_resource(resource)
# ✅ 要这样做：
with acquire_resource() as resource:
use_resource(resource)记住这句话：
"With great power comes great responsibility, but with
withstatement, Python handles the responsibility for you."（能力越大责任越大，但有了
with语句，Python 为你承担责任。）
通过本教程，你已经掌握了 Python with 语句和上下文管理的核心概念。从今天开始，在需要资源管理的地方，请总是使用 with 语句，让你的代码更健壮、更 Pythonic！