关键点：

enter的返回值会赋给as后的变量

exit接收异常类型、值和追踪信息，返回True表示已处理异常

即使发生异常，exit仍会被调用

二、实战场景1：数据库连接池管理

数据库连接是典型需要显式释放的资源。传统方式容易因异常导致连接泄漏：

错误示范：未处理异常时连接泄漏

conn = None

try:

conn = get_db_connection()

cursor = conn.cursor()

cursor.execute("SELECT * FROM users")

# ...其他操作

except Exception as e:

print(f"数据库操作失败：{e}")

finally:

if conn:

conn.close() # 必须手动关闭

用上下文管理器改写后：

from contextlib import contextmanager

class DBConnection:

def init(self, dsn):

self.dsn = dsn

def __enter__(self):
    self.conn = get_db_connection(self.dsn)
    print("数据库连接已建立")
    return self.conn.cursor()
def __exit__(self, exc_type, _, __):
    self.conn.close()
    print("数据库连接已关闭")
    if exc_type:
        self.conn.rollback()
        return True  # 吞掉异常（谨慎使用）

使用示例

with DBConnection("mysql://user:pass@localhost/db") as cursor:

cursor.execute("SELECT * FROM products")

print(cursor.fetchall())

进阶优化：使用contextlib.contextmanager装饰器简化代码：

from contextlib import contextmanager

@contextmanager

def db_connection(dsn):

conn = None

try:

conn = get_db_connection(dsn)

cursor = conn.cursor()

print("数据库连接已建立")

yield cursor # yield前是enter，后是exit

except Exception:

if conn:

conn.rollback()

raise

finally:

if conn:

conn.close()

print("数据库连接已关闭")

三、实战场景2：临时修改系统设置

在测试或特殊场景中，需要临时修改系统设置（如环境变量、日志级别等），使用上下文管理器可确保设置自动恢复：

import os

from contextlib import contextmanager

@contextmanager

def temp_env_var(key, value):

old_value = os.getenv(key)

os.environ = value

try:

yield

finally:

if old_value is None:

del os.environ

else:

os.environ = old_value

使用示例

print(f"原始PATH: {os.getenv('PATH')}")

with temp_env_var('PATH', '/tmp:/usr/bin'):

print(f"临时PATH: {os.getenv('PATH')}")

print(f"恢复后PATH: {os.getenv('PATH')}")

类似应用：

临时修改日志级别

临时切换工作目录

临时修改Python路径（sys.path）

四、实战场景3：性能测试计时器

用上下文管理器自动计算代码块执行时间：

import time

from contextlib import contextmanager

@contextmanager

def timer(name="Operation"):

start = time.time()

try:

yield

finally:

end = time.time()

print(f"{name}耗时: {end-start:.2f}秒")

使用示例

with timer("数据处理"):

result =

x**2 for x in range(1000000)

with timer("数据库查询"):

# 模拟数据库操作
time.sleep(0.5)

输出示例：

数据处理耗时: 0.12秒

数据库查询耗时: 0.50秒

五、实战场景4：线程锁的优雅封装

多线程编程中，锁的获取和释放需要严格配对。上下文管理器可避免忘记释放锁：

import threading

from contextlib import contextmanager

lock = threading.Lock()

@contextmanager

def locked(lock_obj):

lock_obj.acquire()

try:

yield

finally:

lock_obj.release()

使用示例

counter = 0

def increment():

global counter

with locked(lock):

old_val = counter

time.sleep(0.1) # 模拟耗时操作

counter = old_val + 1

threads =

threading.Thread(target=increment) for _ in range(10)

for t in threads:

t.start()

for t in threads:

t.join()

print(f"最终计数器值: {counter}") # 确保输出10

六、实战场景5：网络请求重试机制

封装网络请求的重试逻辑，自动处理临时性失败：

import requests

from contextlib import contextmanager

from time import sleep

@contextmanager

def retry(max_attempts=3, delay=1):

attempt = 0

while attempt < max_attempts:

try:

attempt += 1

yield

break # 成功则退出循环

except requests.exceptions.RequestException as e:

if attempt == max_attempts:

raise

print(f"请求失败（第{attempt}次），{delay}秒后重试...")

sleep(delay)

使用示例

url = "https://httpbin.org/status/500" # 模拟服务器错误

try:

with retry(max_attempts=3, delay=0.5):

response = requests.get(url)

response.raise_for_status()

print("请求成功！")

except requests.exceptions.RequestException as e:

print(f"最终请求失败：{e}")

扩展功能：

指数退避重试

针对特定异常类型重试

记录重试日志

七、实战场景6：临时文件的高级处理

标准库tempfile已提供临时文件支持，但上下文管理器可进一步封装：

import tempfile

from contextlib import contextmanager

@contextmanager

def temp_file(mode='w+', suffix='.tmp'):

file = None

try:

file = tempfile.NamedTemporaryFile(mode=mode, suffix=suffix, delete=False)

yield file # 返回文件对象而非文件名

finally:

if file:

file.close()

        # 示例：不自动删除，交由外部处理
        # os.unlink(file.name)

使用示例

with temp_file('w+') as f:

f.write("临时数据")

f.flush()

print(f"临时文件路径: {f.name}")

# 文件在此处仍存在，可继续操作

对比标准库：

标准NamedTemporaryFile默认删除文件

此实现通过delete=False保留文件，同时确保文件对象正确关闭

八、实战场景7：测试环境的快速搭建/清理

单元测试中，上下文管理器可自动化测试环境的准备和清理：

import shutil

import tempfile

from contextlib import contextmanager

@contextmanager

def test_directory():

temp_dir = tempfile.mkdtemp()

try:

yield temp_dir

finally:

shutil.rmtree(temp_dir)

使用示例（配合pytest）

def test_file_operations():

with test_directory() as dir_path:

test_file = f"{dir_path}/test.txt"

with open(test_file, 'w') as f:

f.write("测试数据")

assert os.path.exists(test_file)

# 退出with后目录自动删除

九、实战场景8：上下文管理器的嵌套使用

多个上下文管理器可嵌套使用（Python 3.10+支持直接嵌套with）：

@contextmanager

def chdir(path):

old_path = os.getcwd()

os.chdir(path)

try:

yield

finally:

os.chdir(old_path)

@contextmanager

def log_commands():

print("开始执行命令...")

try:

yield

finally:

print("命令执行完成")

嵌套使用

with chdir("/tmp"), log_commands():

print(f"当前目录: {os.getcwd()}")

with open("test.txt", 'w') as f:

f.write("Hello")

旧版本Python替代方案：

with chdir("/tmp"):

with log_commands():

    # 代码块

十、实战场景9：上下文管理器的链式调用

通过组合多个上下文管理器实现复杂逻辑：

from contextlib import ExitStack

@contextmanager

def resource_a():

print("获取资源A")

yield "A"

print("释放资源A")

@contextmanager

def resource_b():

print("获取资源B")

yield "B"

print("释放资源B")

使用ExitStack实现链式管理

with ExitStack() as stack:

a = stack.enter_context(resource_a())

b = stack.enter_context(resource_b())

print(f"正在使用资源: {a}, {b}")

# 可动态添加更多资源
if some_condition:
    c = stack.enter_context(resource_a())  # 再次获取A

适用场景：

需要动态管理不确定数量的资源

需要处理部分资源获取失败的情况

常见问题Q&A

Q1：exit方法何时应该返回True？

A：当上下文管理器内部处理了异常且不希望异常继续传播时返回True。例如：

def exit(self, exctype, , __):

if exc_type is ValueError:

print("捕获到ValueError，已处理")

return True # 异常被处理，不会向上传播

return False # 其他异常继续传播

Q2：如何实现异步上下文管理器？

A：Python 3.5+支持异步上下文管理器，需实现aenter()和aexit()方法，或使用@asynccontextmanager装饰器：

from contextlib import asynccontextmanager

@asynccontextmanager

async def async_resource():

await acquire_resource()

try:

yield

finally:

await release_resource()

使用示例

async def main():

async with async_resource():

print("使用异步资源")

Q3：上下文管理器能用于类方法吗？

A：可以，但需注意self的传递：

class MyClass:

@contextmanager

def class_context(self):

print("进入类上下文")

yield self

print("退出类上下文")

obj = MyClass()

with obj.class_context() as ctx:

print(f"上下文中的对象: {ctx}") # ctx是obj本身

Q4：如何调试上下文管理器？

A：在enter和exit中添加日志，或使用装饰器：

def debug_context(func):

def wrapper(args, **kwargs):

print(f"进入 {func.name}")

result = func(args, **kwargs)

print(f"退出 {func.name}")

return result

return wrapper

class DebuggedContext:

@debug_context

def enter(self):

print("实际获取资源逻辑")

return self

@debug_context
def __exit__(self, *args):
    print("实际释放资源逻辑")

结语

上下文管理器是Python中"优雅解决问题"的典范，它通过协议化的设计，将资源管理的通用模式抽象为可复用的组件。从简单的文件操作到复杂的分布式锁，从同步到异步，掌握上下文管理器的高级用法能让你的代码更健壮、更易维护。记住：任何需要"开始-结束"逻辑的场景，都是上下文管理器的潜在应用场景。