Python with 语句和上下文管理器

FreeGuideOnline 最新 2026-07-05

Python `with` 语句：优雅管理资源的钥匙

在编写 Python 程序时，我们经常需要处理外部资源，比如打开文件、获取数据库连接、使用网络套接字等。一个最关键但容易被忽视的环节是：确保无论操作是否成功，这些资源最终都能被正确关闭或释放。忘记关闭文件可能导致数据丢失，放任数据库连接泄漏会耗尽连接池，这类问题被称为“资源泄漏”。

Python 的 with 语句正是为解决这一痛点而生的。它提供了一种简洁、一致且安全的方式来管理资源的生命周期，让你再也不用在每个角落都写上冗余的 try...finally 代码。本文将带你从基础用法入手，深入到自定义上下文管理器的实现，彻底掌握这个让代码更“Pythonic”的核心机制。

1. 从文件操作说起：为什么需要 `with`？

几乎所有 Python 入门教程都会教你这样读写文件：

f = open('data.txt', 'r')
data = f.read()
print(data)
f.close()

这段代码看起来没什么问题，但隐藏着一个巨大的陷阱：如果 f.read() 或 print() 过程中发生了异常，f.close() 将永远不会被执行。这时文件句柄就会一直由进程持有，直到程序退出，造成资源浪费。

为了安全，传统做法是使用 try...finally：

f = open('data.txt', 'r')
try:
    data = f.read()
    print(data)
finally:
    f.close()

这样确实保证了关闭操作一定会执行。但如果你需要处理多个文件，或者逻辑更复杂，代码会迅速被嵌套的 try 块淹没，可读性很差。

with 语句正是为了简化这一模式而设计的。上面的代码可以完美等价于：

with open('data.txt', 'r') as f:
    data = f.read()
    print(data)

当代码块结束后，无论是否发生异常，with 都会自动调用 f.close()。你无需再显式书写清理代码，程序逻辑也变得一目了然。

2. `with` 语句的语法与执行原理

with 语句的基本语法形式为：

with 表达式 [as 目标变量]:
    代码块

它的执行流程严格遵循一套“协议”，这套协议的核心就是上下文管理器（Context Manager）。一个对象只要能支持上下文管理协议，就能用在 with 语句中。协议包含两个特殊方法：

__enter__(self)：进入 with 代码块前被调用。其返回值会被赋值给 as 后面的变量（如果提供了 as）。通常这个返回值就是被管理的资源对象本身。
__exit__(self, exc_type, exc_val, exc_tb)：离开 with 代码块时被调用，无论是因为代码执行完毕，还是由于抛出了异常。三个参数代表异常类型、异常实例对象和追溯对象（traceback）。如果代码块正常结束，这三个参数都是 None。如果该方法返回 True，则代码块内部的异常会被“吞掉”（即不再向上传播）；返回 False 或 None（默认）会让异常继续抛出。

整个 with 语句的执行过程可以看作以下步骤的翻译：

# 1. 计算表达式，获得上下文管理器对象
manager = 表达式
# 2. 调用它的 __enter__ 方法
enter = type(manager).__enter__
exit  = type(manager).__exit__
value = enter(manager)
# 3. 将 __enter__ 的返回值赋给目标变量（如果写了 as）
目标变量 = value
# 4. 执行 with 内部的代码块
try:
    代码块
except:
    # 5. 如果发生异常，调用 __exit__，并传入异常信息
    if not exit(manager, *sys.exc_info()):
        raise   # 若 __exit__ 返回非 True，则重新抛出异常
else:
    # 6. 如果没有异常，正常调用 __exit__，三个参数都是 None
    exit(manager, None, None, None)

看到这里，你应该明白：open('data.txt') 实际上返回的是一个文件对象，而文件对象恰好实现了 __enter__ 和 __exit__ 方法，因此它是一个标准的上下文管理器。__exit__ 负责调用 close()，从而解决了我们最初的问题。

3. 标准库中常见的上下文管理器

除了文件操作，Python 标准库和很多第三方库都大量使用了上下文管理器来简化资源管理。掌握它们的用法，可以让你写出更干净、更可靠的代码。

3.1 线程锁（`threading.Lock`）

在多线程编程中，锁必须在获取后最终被释放，否则会造成死锁。使用 with 可以确保 release() 总是被调用。

import threading

lock = threading.Lock()

# 传统方式
lock.acquire()
try:
    # 访问共享资源
    pass
finally:
    lock.release()

# 使用 with，完全等价
with lock:
    # 访问共享资源
    pass

3.2 数值精度与状态管理（`decimal.localcontext`）

decimal 模块提供了上下文管理器来临时修改小数运算的精度，离开代码块后自动恢复。

from decimal import Decimal, localcontext

tax = Decimal('12.5')
price = Decimal('49.99')

# 全局精度是 28 位
with localcontext() as ctx:
    ctx.prec = 4          # 临时设置精度为 4
    total = price + tax   # 计算会使用 4 位精度
    print(total)          # 输出: 62.49

# 离开 with 后，精度自动恢复为 28
print(Decimal(1) / Decimal(7))  # 高精度输出

3.3 临时目录与文件（`tempfile.TemporaryDirectory`）

创建临时文件夹，使用完毕后自动递归删除，非常适合测试或中间计算。

from tempfile import TemporaryDirectory
import os

with TemporaryDirectory() as tmpdirname:
    print(f"临时目录已创建: {tmpdirname}")
    with open(os.path.join(tmpdirname, 'test.txt'), 'w') as f:
        f.write("Hello")
    # 在这里可以随意读写
# 离开 with 后，整个临时目录及其内容会被自动清理

3.4 其他示例速览

contextlib.redirect_stdout：临时重定向标准输出。
unittest.mock.patch：测试中对对象进行模拟，离开作用域后自动还原。
数据库连接：如 sqlite3.connect() 返回的连接对象可以作为上下文管理器，自动提交或回滚事务。

4. 深入 `exit`：优雅地处理异常

__exit__ 方法的最大好处不是自动执行清理，而是它能感知并决定如何处理代码块内部发生的异常。

考虑一个场景：你需要操作一个远程资源，如果操作失败，希望自动关闭连接，但不能让异常把程序搞崩，而是转为一个特定的返回值。这时 __exit__ 就可以吞掉异常。

class SuppressException:
    def __enter__(self):
        print("进入上下文，开始危险操作...")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is ZeroDivisionError:
            print(f"捕获到除零错误: {exc_val}，但被吞掉。")
            return True  # 吞掉异常，程序不会崩溃
        # 对于其他异常，返回 False，让其正常抛出
        print("其他异常，向上抛出。")
        return False

with SuppressException():
    x = 1 / 0   # 这里会触发 ZeroDivisionError
    print("这行不会被执行")

print("程序继续运行！")

输出：

进入上下文，开始危险操作...
捕获到除零错误: division by zero，但被吞掉。
程序继续运行！

如果不返回 True，异常就会像往常一样中断程序。这个特性在编写需要回滚操作的上下文管理器时尤其有用：在 __exit__ 里判断是否有异常，如果有，就执行回滚逻辑，然后决定是否要传播异常。

5. 创建自己的上下文管理器

Python 提供了两种主要方式来创建自定义的上下文管理器：类方式和生成器方式。前者适合复杂的、需要保持状态的管理器；后者通过 contextlib.contextmanager 装饰器可以将一个生成器函数转换为上下文管理器，代码极为简洁。

5.1 方式一：实现 `enter` 和 `exit` 的类

假设我们要写一个计时器，用来测量代码块的执行时间。

import time

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        # 这里可以返回 self，或者别的对象
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.perf_counter()
        self.elapsed = self.end - self.start
        print(f"代码块执行耗时: {self.elapsed:.6f} 秒")
        # 不处理异常，直接返回 False（或 None），异常会继续传播
        return False

# 使用
with Timer() as t:
    # 模拟耗时操作
    total = sum(range(100_000))
    print("计算完成")

# 输出中包含计时信息

这个 Timer 类就是一个标准的上下文管理器。__enter__ 记录开始时间并返回实例本身，__exit__ 计算耗时并打印。

5.2 方式二：使用 `@contextmanager` 装饰器（生成器）

对于更简单的逻辑，使用 contextlib.contextmanager 可以把一个生成器函数变成上下文管理器。生成器中 yield 之前的代码相当于 __enter__，yield 本身可以返回一个值给 as 目标；yield 之后的代码相当于 __exit__。异常处理可以直接用 try...except 包住 yield。

看一个实现“打开并自动关闭容器”的例子：

from contextlib import contextmanager

@contextmanager
def managed_list(initial_data):
    # __enter__ 的逻辑
    data = list(initial_data)
    print("列表已创建，可进行操作")
    try:
        # yield 将 data 传出给 as 后的变量
        yield data
    except Exception as e:
        # 可以在这里处理异常，决定是吞掉还是重新抛出
        print(f"操作过程中发生异常: {e}")
        # 重新抛出，让调用者感知
        raise
    finally:
        # __exit__ 的清理逻辑，一定会执行
        data.clear()
        print("列表已清空，资源被释放")

# 使用
with managed_list([1, 2, 3]) as my_list:
    my_list.append(4)
    print(f"列表内容: {my_list}")
    # 如果不加 try，发生异常也会执行 finally 清理

# 输出:
# 列表已创建，可进行操作
# 列表内容: [1, 2, 3, 4]
# 列表已清空，资源被释放

使用生成器方式时要注意：生成器只能被消耗一次，且必须在 yield 处暂停。这种方法代码量少，可读性强，非常适合简单的资源获取/释放场景。如果你的管理器需要保存复杂状态，或者需要在 __enter__ 之后、__exit__ 之前被多方调用，类方式会更合适。

6. 进阶技巧与最佳实践

6.1 嵌套多个上下文管理器

Python 支持在一条 with 语句中同时管理多个资源，只需用逗号分隔即可。这比嵌套的 with 更能体现扁平化结构。

with open('input.txt') as fin, open('output.txt', 'w') as fout:
    for line in fin:
        fout.write(line.upper())

从 Python 3.10 开始，还可以使用括号让多行嵌套更加清晰：

with (
    open('a.txt') as f1,
    open('b.txt') as f2,
    open('c.txt') as f3
):
    # 同时处理三个文件
    pass

6.2 异步上下文管理器（`async with`）

在异步编程中，许多资源也需要异步获取和释放（比如异步网络会话）。Python 通过 __aenter__ 和 __aexit__ 方法提供了与同步 with 完全对应的 async with 语句。

import asyncio
import aiohttp

async def fetch_data():
    async with aiohttp.ClientSession() as session:
        async with session.get('https://api.example.com') as resp:
            data = await resp.json()
    # 离开上下文时，session 和 response 都会自动关闭
    return data

创建异步上下文管理器的生成器版本可以使用 @asynccontextmanager 装饰器。

6.3 不要重复造轮子：`contextlib` 工具箱

标准库 contextlib 提供了许多有用的工具，能极大减少你的代码量：

closing(thing)：将一个仅有 close() 方法但不实现上下文协议的对象包装成上下文管理器。例如，urlopen() 返回的对象在旧版本中就需要这样处理。
suppress(*exceptions)：优雅地忽略指定的异常。with suppress(FileNotFoundError): os.remove('somefile')。
redirect_stdout(new_target)：临时重定向 print 的输出。
ExitStack：动态管理多个上下文管理器，尤其适合在运行时才知道需要进入哪些上下文的场景。它能保证当某个管理器进入失败时，之前已经进入的管理器都能被正确退出。

6.4 编写健壮上下文管理器的原则

__exit__ 永远不应该抛出异常。如果清理代码本身可能出错，应该在内部用 try...except 记录日志或处理，避免掩盖原始代码块的异常。
考虑可重入性。如果上下文管理器会被嵌套使用，要确保状态不会互相干扰。
在 __exit__ 中恰当处理异常。除非你明确知道需要吞掉异常，否则返回 False 让异常正常传播，这符合大多数场景的预期。
优先使用生成器方式，除非逻辑过于复杂或需要保持超出 yield 范围的状态。

7. 总结

with 语句是 Python 语言设计中“清晰优于隐式”哲学的典范。它将资源获取与释放的逻辑打包在一起，让“善后工作”变得自动、可靠且不可见。通过学习本文，你应该已经掌握：

为什么 try...finally 模式被 with 取代。
上下文管理器协议（__enter__ 和 __exit__）的内部机制。
内置库中线程锁、文件、临时目录等资源的管理方式。
使用 __exit__ 参数控制异常处理。
通过类和 @contextmanager 生成器两种方式自定义上下文管理器。
多管理器嵌套、异步 async with 以及 contextlib 实用工具。

现在，请在你的下一个项目中使用 with 来管理所有需要“打开-关闭”的资源。这不仅会让你的代码更安全，更会让你体会到 Python 那种极致的简洁与表达力。

Python with 语句：优雅管理资源的钥匙

1. 从文件操作说起：为什么需要 with？

2. with 语句的语法与执行原理

3. 标准库中常见的上下文管理器

3.1 线程锁（threading.Lock）

3.2 数值精度与状态管理（decimal.localcontext）

3.3 临时目录与文件（tempfile.TemporaryDirectory）