对话实录

小白：（抓狂）我写了f = open("data.txt")，结果忘记关闭文件了！

专家：（掏出魔法书）用 with 语句，文件自动关闭，永不泄露！

上下文管理器基础三连击

1. 基本用法

# 传统写法（危险！）
f = open("data.txt")
try:
 content = f.read()
finally:
 f.close()

#with写法（推荐！）
with open("data.txt") as f:
 content = f.read() # 自动关闭文件

专家提醒：任何需要清理的资源，如文件、数据库连接、网络套接字等，都要用with语句！传统写法中，若在try块内发生异常，文件可能无法正常关闭，导致资源泄露。而with语句通过上下文管理器，无论代码块内是否发生异常，都会自动关闭文件，确保资源被正确释放。

2. 自定义上下文管理器

class Timer:
    def __enter__(self):
        self.start = time.time()
        return self
    
    def __exit__(self, *args):
        self.duration = time.time() - self.start
        print(f"耗时：{self.duration:.2f}秒")

with Timer():
    time.sleep(1)  # → 耗时：1.00秒

通过实现__enter__和__exit__方法，我们可以创建自定义的上下文管理器。__enter__方法在进入with代码块时被调用，通常用于初始化资源；__exit__方法在离开with代码块时被调用，用于清理资源。

六大实战案例

案例 1：数据库连接

import sqlite3

class DBConnection:
    def __enter__(self):
        self.conn = sqlite3.connect("test.db")
        return self.conn.cursor()
    
    def __exit__(self, type, value, traceback):
        self.conn.commit()
        self.conn.close()

with DBConnection() as cursor:
    cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY)")

在数据库操作中，使用上下文管理器可以确保数据库连接在使用完毕后被正确关闭，同时自动提交事务，避免数据丢失或不一致的问题。

案例 2：线程锁管理

import threading
lock = threading.Lock()
with lock: # 自动获取和释放锁
	# 执行线程安全操作
	print("临界区代码")

在多线程编程中，线程锁用于保护共享资源，防止多个线程同时访问导致数据不一致。with语句结合线程锁，在进入代码块时自动获取锁，离开时自动释放锁，确保临界区代码的线程安全性。

案例 3：临时目录

from contextlib import contextmanager
import tempfile
import shutil

@contextmanager
def temp_dir():
    dirpath = tempfile.mkdtemp()
    try:
        yield dirpath
    finally:
        shutil.rmtree(dirpath)

with temp_dir() as tmp:
    print(f"使用临时目录：{tmp}")  # 自动清理

contextlib.contextmanager装饰器提供了一种更简洁的方式来创建上下文管理器。在这个案例中，temp_dir上下文管理器创建一个临时目录，在with代码块结束后自动删除该目录，避免在磁盘上留下不必要的文件。

案例 4：文件备份

import shutil

class FileBackup:
    def __init__(self, source, target):
        self.source = source
        self.target = target

    def __enter__(self):
        shutil.copy2(self.source, self.target)
        return self

    def __exit__(self, type, value, traceback):
        pass

with FileBackup("data.txt", "data_backup.txt"):
    print("数据已备份")

在进行文件操作时，有时需要先对文件进行备份。FileBackup上下文管理器在进入with代码块时，将源文件复制到目标位置，实现文件备份功能。

案例 5：日志记录

import logging

class LoggingContext:
    def __init__(self, level):
        self.level = level

    def __enter__(self):
        self.old_level = logging.getLogger().getEffectiveLevel()
        logging.getLogger().setLevel(self.level)
        return self

    def __exit__(self, type, value, traceback):
        logging.getLogger().setLevel(self.old_level)

with LoggingContext(logging.DEBUG):
    logging.debug("这是一条调试日志")

在开发过程中，我们可能需要根据不同的场景调整日志级别。LoggingContext上下文管理器在进入with代码块时，将日志级别设置为指定值，离开时恢复原来的日志级别，方便灵活地控制日志输出。

案例 6：资源监控

import resource

class ResourceMonitor:
    def __enter__(self):
        self.start_usage = resource.getrusage(resource.RUSAGE_SELF)
        return self

    def __exit__(self, type, value, traceback):
        end_usage = resource.getrusage(resource.RUSAGE_SELF)
        print(f"CPU时间：{end_usage.ru_utime - self.start_usage.ru_utime}秒")
        print(f"内存使用：{end_usage.ru_maxrss - self.start_usage.ru_maxrss}KB")

with ResourceMonitor():
    for _ in range(1000000):
        pass

ResourceMonitor上下文管理器可以在代码块执行前后监控 CPU 时间和内存使用情况，帮助我们分析代码的性能，找出潜在的性能瓶颈。

四大血泪陷阱

忘记实现__exit__

class BadManager:
    def __enter__(self):
        print("进入")
        # 忘记实现__exit__ 

with BadManager():  报错

如果自定义上下文管理器没有实现__exit__方法，在使用with语句时会抛出AttributeError异常。确保在创建上下文管理器时，正确实现__enter__和__exit__方法。

异常处理不当

class DangerManager:
    def __exit__(self, type, val, tb):
        return True  #  吞掉所有异常

with DangerManager():
    1 / 0  # 错误被静默吞掉！

__exit__方法的返回值决定了是否抑制异常。如果返回True，异常将被抑制，导致错误信息无法被正确处理。在处理异常时，应根据实际需求合理返回，避免吞掉重要的错误信息。

资源泄漏

# 错误示范
file = open("data.txt")
content = file.read()
# 忘记file.close()
# 正确做法
with open("data.txt") as file:
	content = file.read()

在使用资源时，如果忘记手动关闭资源，可能会导致资源泄漏。使用with语句可以有效避免这种情况，确保资源在使用完毕后被正确释放。

上下文管理器嵌套错误

#错误示范
with open("a.txt") as f1:
    with open("b.txt") as f2:
        pass

# 正确做法
with open("a.txt") as f1, open("b.txt") as f2:
    pass

虽然多层嵌套的with语句可以正常工作，但使用多重上下文语法可以使代码更加简洁，同时减少缩进层级，提高代码的可读性。

专家工具箱

1. contextlib模块

from contextlib import contextmanager

@contextmanager
def tag(name):
    print(f"<{name}>")
    yield
    print(f"</{name}>")

with tag("html"):
    print("网页内容")  # → <html>网页内容</html>

contextlib.contextmanager装饰器简化了上下文管理器的创建过程。通过定义一个生成器函数，在yield语句前后分别编写进入和退出上下文的逻辑，即可创建一个上下文管理器。

2. 异步上下文

class AsyncManager:
    async def __aenter__(self):
        print("异步进入")
    
    async def __aexit__(self, *args):
        print("异步退出")

async def main():
    async with AsyncManager():
        print("执行操作")

在异步编程中，异步上下文管理器通过__aenter__和__aexit__方法实现类似的功能。async with语句用于管理异步资源，确保资源在异步操作结束后被正确清理。

小白：（献上膝盖）原来上下文管理器这么强大！

专家：（扶起小白）记住：with语句是 Python 的优雅之道！

冷知识：上下文管理器的隐藏特性

• 可重入性：某些上下文管理器支持在同一个线程中多次进入和退出，确保资源的正确管理。
• 上下文栈：Python 维护一个上下文栈，用于管理多个上下文管理器的嵌套调用，保证资源的清理顺序正确。
• 与try - finally的关系：with语句本质上是try - finally的语法糖，通过上下文管理器简化了资源管理的代码。