#Python context management (Context Manager) and contextlib quick start

In Python development, resource management is almost everywhere: open files, database connections, network requests, temporary directories... These resources all have one thing in common: they must be released when used up. If you only write "Get resources → Use resources" in the code, once an exception is thrown in the middle, the cleanup code will be skipped, which will waste memory at best, and cause serious problems such as file handle leaks and connection pool exhaustion. This article takes you from the originaltry...finallygradually evolve towithstatement and powerfulcontextlibModule, write safe, concise, Pythonic resource management code.

#1. Why should we pay attention to resource management?

Imagine the simplest file reading scenario:

f = open("data.txt", "r", encoding="utf-8")
data = f.read()
f.close()

ifread()Throws an exception (such as file corruption or disk error) and the program crashes directly,close()No chance at all to execute. The file handle is occupied, which means that the file cannot be accessed after the program is restarted, or that the file descriptors of the entire process are exhausted.

The most original remedy is to usetry...finallyForced to tell the truth:

f = None
try:
    f = open("data.txt", "r", encoding="utf-8")
    data = f.read()
finally:
    if f:                     # 确保 f 已被绑定，避免 NameError
        f.close()

In this way, even if an error occurs midway, cleanup will be performed. But the shortcomings are also obvious: cleaning logic and business logic are mixed, the code is bloated, and you have to remember to judge every timefWhether created successfully.

#2. Python native solution:withstatement

Python 2.5 introducedwithSyntactic sugar, specifically solving the "enter-use-exit" pattern. The above example can be simplified to:

with open("data.txt", "r", encoding="utf-8") as f:
    data = f.read()

Two lines of code complete the safe opening and automatic closing of files, even ifread()Throw an exception,f.close()will also be called. This writing method is both concise and safe, and is the resource management method recommended by Python.

#3. What objects can be put in?with? Contextual protocol!

Only objects that implement the Context Management Protocol can interact withwithused together. The protocol requires the object to provide two magic methods:

#3.1 Handwrite a database connection context class

Let’s understand these two methods through an example of simulating a database connection:

class DatabaseConnection:
    def __init__(self, db_name: str):
        self.db_name = db_name
        self.connection = None

    def __enter__(self):
        # 建立连接
        print(f"🔗 正在连接数据库 {self.db_name}")
        self.connection = f"MockConnection({self.db_name})"
        return self                # 返回自身，供 with ... as 使用

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 无论如何都会执行关闭操作
        print(f"🔒 正在关闭数据库连接 {self.db_name}")
        self.connection = None
        # 三个参数分别是：异常类型、异常实例、traceback，无异常时均为 None
        if exc_type:
            print(f"⚠️ 捕获到异常：{exc_type.__name__} - {exc_val}")
        # 若返回 True，异常会被“吞掉”，外部不会感知
        return False

    def query(self, sql: str):
        print(f"📝 执行SQL：{sql}")
        return [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]

# 使用示例
with DatabaseConnection("local_test") as db:
    users = db.query("SELECT * FROM users")
    print(f"📦 查询结果：{users}")

After running, you will find that evenquery()If an error occurs, the log of the closed connection will also be output, ensuring that the resources will be released.

#4. UsecontextlibBeing Lazy: How to Avoid Handwriting Magic

Realize it with your own hands__enter__and__exit__Very clear, but too formal in some simple scenes.contextlibThe standard library provides several shortcuts that allow you to create context managers with very little code.

#4.1 Most commonly used:@contextmanagerDecorator

@contextmanagerA ** can be includedyieldThe generator function ** is converted directly into the context manager. The execution flow of the generator corresponds to the three steps of the context manager:

• yieldbefore part →__enter__logic
• yieldThe value that comes out →__enter__return value (forasuse)
• yieldAfter part →__exit__Logic (must be usedtry...finallypackage, otherwise the cleanup code will not be executed when an exception occurs)

#Rewrite the database connection with a generator

from contextlib import contextmanager

# 模拟的数据库连接对象，可以用任意真实类代替
class MockConnection:
    def __init__(self, name):
        self.name = name

    def query(self, sql):
        print(f"📝 执行SQL：{sql}")
        return []

@contextmanager
def database_connection(db_name: str):
    print(f"🔗 正在连接数据库 {db_name}")
    conn = MockConnection(db_name)        # 模拟连接建立
    try:
        yield conn                        # 将连接对象交给 with 块
    finally:
        print(f"🔒 正在关闭数据库连接 {db_name}")
        # 在这里执行任何清理操作，如关闭连接、释放锁等

# 使用方式和普通上下文管理器完全一样
with database_connection("mydb") as db:
    db.query("SELECT 1")

#A more intuitive example: HTML tag nesting

If you only need to switch environments (or states) when entering and exiting, the generator writing method is especially elegant:

@contextmanager
def html_tag(tag_name: str):
    print(f"<{tag_name}>")
    yield
    print(f"</{tag_name}>")

# 嵌套使用就像写标签一样
with html_tag("div"):
    with html_tag("h1"):
        print("Hello Python Context Manager!")
    with html_tag("p"):
        print("这是用 @contextmanager 生成的标签上下文。")

Output result:

<div>
<h1>
Hello Python Context Manager!
</h1>
<p>
这是用 @contextmanager 生成的标签上下文。
</p>
</div>

#4.2 Adapter tool:closing()

Many third-party library objects provideclose()method, but does not implement the context management protocol, such as the early built-inurllib.request.urlopen. It can be used at this timeclosing()Give it a "shell":

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen("https://www.python.org")) as page:
    for i, line in enumerate(page):
        if i >= 2:
            break
        print(line.decode("utf-8")[:100])

closing()The object will be automatically called when exitingclose()method regardless of whether an exception occurs.

#4.3 Batch management tools:ExitStack

If you need to manage an undetermined number of dynamic contexts at the same time (such as looping open files), use nestingwithIt would be very troublesome or even impossible.ExitStackThis is what it’s made for:

from contextlib import ExitStack
from pathlib import Path

def merge_files(input_files: list[Path], output_file: Path):
    with ExitStack() as stack:
        # 动态将所有输入文件加入栈
        files = [stack.enter_context(open(f, "r", encoding="utf-8"))
                 for f in input_files]
        # 加入输出文件
        out = stack.enter_context(open(output_file, "w", encoding="utf-8"))

        # 合并写入
        for f in files:
            out.write(f.read())
            out.write("\n=== 分割线 ===\n")

# 调用示例
merge_files(
    [Path("part1.txt"), Path("part2.txt"), Path("part3.txt")],
    Path("full.txt")
)

ExitStackEach context will be automatically called in reverse order of entry.__exit__Method that cleans up all resources correctly even if something goes wrong along the way.

#5. Modern Python Best Practices

Once you master context managers, you can incorporate the following principles into your daily coding:

1. can be usedwithNo needtry...finally. Files, locks, database sessions, network connections, etc. should all be enteredwith"protective umbrella".
2. Make good use ofcontextlibReduce template code. For simple scenes@contextmanager, used to adapt to old interfacesclosing(), for dynamic resource managementExitStack。
3. The way to write the generator must betry...finally. otherwiseyieldThe cleanup code may never execute afterwards.
4. ** Give with caution__exit__returnTrue**. Unless you absolutely need to swallow an exception, let it propagate up normally to avoid hiding errors.
5. Type annotation improves readability. Python 3.6+ availabletyping.ContextManager, 3.9+ is still availablecontextlib.AbstractContextManagerAnnotate your context manager return type.

#6. Two extremely practical practical cases

#6.1 Automatically delete temporary directories

Temporary directories are often needed for testing or data processing and should be deleted after use.tempfile.mkdtempYou are only responsible for creation, and you have to delete it yourself, which is easy to forget. use@contextmanagerWrap it up and sit back and relax:

import tempfile
import shutil
from pathlib import Path
from contextlib import contextmanager

@contextmanager
def auto_clean_temp_dir(prefix: str = "tmp_", suffix: str = "") -> Path:
    temp_dir = Path(tempfile.mkdtemp(prefix=prefix, suffix=suffix))
    try:
        yield temp_dir                     # 把目录路径交给业务代码
    finally:
        if temp_dir.exists():
            shutil.rmtree(temp_dir)
            print(f"🗑️ 已删除临时目录：{temp_dir}")

# 使用
with auto_clean_temp_dir(prefix="test_ctx_") as td:
    test_file = td / "draft.txt"
    test_file.write_text("临时内容")
    print(f"📄 已创建：{test_file}")

#6.2 Automatic commit/rollback of database transactions

When operating databases in web development, we often hope that "a batch of operations will either succeed or fail." Transaction behavior can be easily encapsulated using context managers:

from contextlib import contextmanager

@contextmanager
def auto_transaction(session):
    # 如果已经在事务中，就直接 yield，避免嵌套
    if session.in_transaction():
        yield
        return
    # 开启一个新事务
    session.begin()
    try:
        yield
        session.commit()
        print("✅ 事务已提交")
    except Exception as e:
        session.rollback()
        print(f"❌ 事务已回滚：{e}")
        raise  # 异常继续向上传播，不隐藏错误

When using it, just put the database operation inwith auto_transaction(session):Within the block, all successful operations are automatically submitted, and errors are automatically rolled back.

#Summarize

Context managers are the cornerstone of Python resource management. from manualtry...finallyto elegantwith, and then to the standard librarycontextlibWith various auxiliary tools provided, your code will become more secure, concise and readable. Next time you encounter a scene that requires "open-use-close", you might as well ask yourself: Can it be used?withDone? **

Most of the time, the answer is yes.