文章目录
一.什么是上下文管理器
上下文管理器是Python中用于管理资源的对象，它定义了在进入和退出代码块时要执行的操作。上下文管理器通过with语句使用，确保资源被正确获取和释放，即使在代码块中发生异常也是如此。
上下文管理器主要实现两个特殊方法：
enter(): 进入上下文时执行，返回资源对象
exit(): 退出上下文时执行，处理清理工作
基本语法
with context_manager as resource:
# 使用资源的代码块
pass
二.创建上下文管理器方法
1.使用类来实现
class DatabaseConnection:
def __init__(self, db_name):
self.db_name = db_name
def __enter__(self):
print(f"Connecting to {self.db_name}")
self.connection = "模拟的数据库连接" # 实际中这里会建立真实连接
return self.connection
def __exit__(self, exc_type, exc_val, exc_tb):
print(f"Closing connection to {self.db_name}")
self.connection = None # 实际中这里会关闭连接
# 使用示例
with DatabaseConnection("my_database") as conn:
print(f"Using connection: {conn}")
# 执行数据库操作
# 在这个代码块中，DatabaseConnection已经被正确进入
# 代码块执行完毕后，__exit__方法会被自动调用
2.使用contextlib模块
contextlib模块提供了 contextmanager 装饰器，使得创建上下文管理器变得更加简单。使用该装饰器，你只需编写一个生成器函数，并使用 yield 语句来定义进入和退出代码块时的行为。
from contextlib import contextmanager
@contextmanager
def database_connection(db_name):
print(f"Connecting to {db_name}")
connection = "模拟的数据库连接"
try:
yield connection
finally:
print(f"Closing connection to {db_name}")
connection = None
# 使用示例
with database_connection("my_database") as conn:
print(f"Using connection: {conn}")
# 执行数据库操作
# 在这个代码块中，database_connection已经被正确进入
# 代码块执行完毕后，yield之后的代码会被执行
三.上下文管理器的应用
1.文件的读写
上下文管理器在文件操作中特别有用，可以确保在读取或写入文件后正确关闭文件句柄，避免资源泄漏。
方法一
# 定义一个自定义上下文管理器
class FileHandler:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
def __enter__(self):
print("打开文件")
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
print("关闭文件")
self.file.close()
# 使用 with 语句操作文件
with FileHandler('example.txt', 'w') as f:
f.write("Hello, Context Manager!")
# 如果发生异常，也会触发 __exit__
raise ValueError("模拟错误")
在这个例子中，FileHandler 类实现了上下文管理器协议。当我们使用 with 语句时，Python 会自动调用 enter 方法来打开文件，并在 with 块结束时调用 exit 方法来关闭文件
方法二
from contextlib import contextmanager
@contextmanager
def open_file(path, mode):
f = open(path, mode)
try:
yield f
finally:
f.close()
# 使用示例
with open_file('config.json', 'r') as f:
content = f.read()
print(content)
2.数据库连接管理
在数据库操作中，上下文管理器可以用于确保数据库连接在使用完毕后被正确关闭。
2.1连接sqlite
方法一
import sqlite3
class DatabaseConnection:
def __init__(self, db_name):
self.db_name = db_name
def __enter__(self):
print("连接数据库")
self.conn = sqlite3.connect(self.db_name)
return self.conn
def __exit__(self, exc_type, exc_val, exc_tb):
print("关闭数据库连接")
self.conn.close()
# 使用 with 语句操作数据库
with DatabaseConnection('test.db') as conn:
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
cursor.execute("INSERT INTO users (name) VALUES ('Alice')")
conn.commit()
在这个例子中，我们创建了一个 DatabaseConnection 类来管理 SQLite 数据库连接。通过 with 语句，我们可以确保无论是否发生异常，数据库连接都会被正确关闭。
方法二
import sqlite3
from contextlib import contextmanager
@contextmanager
def get_db_connection(db_path):
conn = sqlite3.connect(db_path)
try:
yield conn
finally:
conn.close()
# 使用示例
with get_db_connection("app.db") as conn:
cursor = conn.cursor()
cursor.execute("SELECT * FROM users")
results = cursor.fetchall()
print(results)
2.2连接mysql
方法一
enter 方法初始化数据库连接并开启事务。
exit 方法根据异常状态决定提交或回滚，并关闭连接。
import pymysql
class DBConnection:
def __init__(self, host, user, password, db):
self.host = host
self.user = user
self.password = password
self.db = db
self.conn = None
def __enter__(self):
self.conn = pymysql.connect(
host=self.host,
user=self.user,
password=self.password,
db=self.db
)
self.conn.begin # 开启事务
return self.conn # 返回连接对象
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type: # 发生异常时回滚
self.conn.rollback
print("事务回滚")
else: # 正常执行时提交
self.conn.commit
print("事务提交")
self(conn.close) # 关闭连接
# 使用示例
try:
with DBConnection("localhost", "user", "password", "mydb") as conn:
cursor = conn.cursor
cursor.execute("INSERT INTO users (name) VALUES ('Alice')")
except Exception as e:
print(f"错误：{e}")
方法二
优势
代码更简洁，无需定义完整类，适合一次性场景。
from contextlib import contextmanager
import pymysql
@contextmanager
def managed_db_connection(host, user, password, db):
conn = pymysql.connect(host=host, user=user, password=password, db=db)
try:
conn.begin
yield conn # 将连接传递给代码块
except Exception as e:
conn.rollback
print(f"事务回滚：{e}")
else:
conn.commit
print("事务提交")
finally:
conn.close
# 使用示例
with managed_db_connection("localhost", "user", "password", "mydb") as conn:
cursor = conn.cursor
cursor.execute("UPDATE accounts SET balance=balance-100 WHERE id=1")
一、关键特性与注意事项
-
自动资源管理
无论代码块是否抛出异常，连接和事务都会被正确释放，避免资源泄漏。 -
异常处理
- 在
__exit__方法中，通过检查exc_type判断是否发生异常。 - 若返回
True，可阻止异常向上传播；若返回False，异常会继续抛出。
- 在
-
多数据库支持
上下文管理器逻辑适用于多种数据库（如MySQL、SQLite），仅需调整连接参数和事务方法。
二、应用场景
- 数据库事务控制
确保多个操作的原子性，例如转账时的扣款和加款操作。 - 连接池管理
结合连接池库（如DBUtils），实现高效连接复用。 - 复杂业务逻辑
在需要回滚的场景（如订单创建失败时释放库存）中，简化代码结构。
五、对比传统方法
| 传统方法 | 上下文管理器 |
|---|---|
需手动调用 commit() 和 close() | 自动提交/回滚和关闭连接 |
异常处理需嵌套 try/finally | 通过 __exit__ 统一处理 |
| 代码冗余，易遗漏步骤 | 代码简洁，逻辑清晰 |
通过合理使用上下文管理器，可以显著提升数据库操作的健壮性和可维护性。具体实现可根据项目需求选择类方法或装饰器方法。
3.数据库事务管理
@contextmanager
def transaction(conn):
try:
yield
conn.commit()
print("Transaction committed")
except Exception as e:
conn.rollback()
print(f"Transaction rolled back due to: {e}")
raise
# 使用示例
with get_db_connection("app.db") as conn:
with transaction(conn):
cursor = conn.cursor()
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)",
("Alice", "alice@example.com"))
4.redis连接管理
import redis
from contextlib import contextmanager
@contextmanager
def redis_connection(host='localhost', port=6379, db=0):
r = redis.Redis(host=host, port=port, db=db)
try:
yield r
finally:
r.close()
# 使用示例
with redis_connection() as r:
r.set('some_key', 'some_value')
value = r.get('some_key')
print(value)
5.临时文件管理
import tempfile
import shutil
from contextlib import contextmanager
@contextmanager
def temp_directory():
temp_dir = tempfile.mkdtemp()
try:
yield temp_dir
finally:
shutil.rmtree(temp_dir)
# 使用示例
with temp_directory() as temp_dir:
print(f"Working in temporary directory: {temp_dir}")
# 在此目录中创建和处理临时文件
6.请求上下文管理（如Flask）
from flask import Flask, g
from contextlib import contextmanager
app = Flask(__name__)
@contextmanager
def request_context():
# 模拟Flask的请求上下文
g.db = "模拟的数据库连接"
try:
yield
finally:
g.db = None # 清理资源
# 使用示例
with app.app_context(), request_context():
print(f"Current DB connection: {g.db}")
# 处理请求
7.API请求超时管理
import requests
import signal
from contextlib import contextmanager
class TimeoutException(Exception):
pass
@contextmanager
def timeout(seconds):
def signal_handler(signum, frame):
raise TimeoutException("Timed out!")
signal.signal(signal.SIGALRM, signal_handler)
signal.alarm(seconds)
try:
yield
finally:
signal.alarm(0)
# 使用示例
try:
with timeout(5): # 5秒超时
response = requests.get('https://api.example.com/data')
print(response.json())
except TimeoutException:
print("API request timed out")
8.性能分析
import time
from contextlib import contextmanager
@contextmanager
def timer(name):
start = time.time()
try:
yield
finally:
end = time.time()
print(f"{name} took {end - start:.2f} seconds")
# 使用示例
with timer("Database query"):
# 模拟耗时操作
time.sleep(1.5)
9.异步上下文管理器（Python 3.7+）
import aiohttp
from contextlib import asynccontextmanager
@asynccontextmanager
async def async_http_session():
session = aiohttp.ClientSession()
try:
yield session
finally:
await session.close()
# 使用示例
async def fetch_data():
async with async_http_session() as session:
async with session.get('https://api.example.com/data') as response:
return await response.json()
总结
上下文管理器在后端开发中的应用非常广泛，主要包括：
- 资源管理：确保文件、网络连接、数据库连接等资源被正确释放
- 事务管理：确保数据库操作的原子性
- 异常处理：在资源清理时处理可能出现的异常
- 上下文设置：管理请求上下文、配置环境等
- 性能监控：测量代码块的执行时间
- 临时资源：管理临时文件和目录
使用上下文管理器的好处包括：
- 代码更简洁、更可读
- 资源管理更安全，减少泄漏风险
- 异常处理更健壮
- 减少样板代码
在后端开发中，合理使用上下文管理器可以显著提高代码的健壮性和可维护性。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
