Python Context Managers

Some resources must be released after use: files, network connections, database transactions, locks and temporary directories. Without with, you need try/finally to be sure the release happens:

file = open("log.txt", "a", encoding="utf-8")
try:
    file.write("Session started\n")
finally:
    file.close()

with packages that pattern into one line and makes it impossible to forget:

with open("log.txt", "a", encoding="utf-8") as file:
    file.write("Session started\n")

The clean-up runs when the block finishes normally, when it raises an exception, and when it exits early through return, break or continue. Several managers can share one statement, with open(a) as src, open(b, "w") as dst:, and they are cleaned up in reverse order. From Python 3.10 you can wrap a long list of managers in brackets across several lines.

Any object with two special methods is a context manager:

• __enter__(self) runs at the start of the block. Its return value is bound to the name after as.
• __exit__(self, exc_type, exc_value, traceback) runs at the end. If the block raised an exception, the three arguments describe it; otherwise all three are None.

class ObservingSession:
    def __enter__(self):
        print("Open dome")
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        print("Close dome")
        return False          # don't suppress exceptions

If __exit__ returns a truthy value, Python treats the exception as handled and continues after the with block. Returning False or None lets it propagate as normal. Suppressing exceptions should be deliberate and narrow; a manager that returns True for everything hides bugs. contextlib.suppress(FileNotFoundError) is the standard tool when you really do want to ignore one specific error.

The name after as receives whatever __enter__ returns, which is not necessarily the manager itself:

class Telescope:
    def __init__(self, target):
        self.target = target
    def __enter__(self):
        print("Pointing telescope")
        return self.target        # bind the target, not the Telescope
    def __exit__(self, *exc):
        print("Parking telescope")

with Telescope("Jupiter") as target:
    print("Observing", target)

open() returns a file object whose __enter__ returns itself, which is why with open(...) as f gives you the file. A database connection's __enter__, on the other hand, may return a cursor or a transaction. Check the documentation of each manager, and remember that as is optional: with lock: is perfectly valid when you don't need a name.

Writing a class with two methods is verbose for simple cases. contextlib.contextmanager turns a generator function into a context manager: code before yield is the set-up, the yielded value is bound by as, and code after yield is the clean-up.

from contextlib import contextmanager

@contextmanager
def observing_session(target):
    print("Open dome")
    try:
        yield target
    finally:
        print("Close dome")

If the with block raises an exception, it is re-raised at the yield inside your generator. That's why essential clean-up belongs in a finally around the yield: without it, an exception would skip the clean-up line entirely. The generator must yield exactly once; yielding twice, or not at all, raises RuntimeError. To handle the exception rather than just clean up, wrap the yield in try/except.

Task: verify that an observing manager closes after successful work and after a raised exception.

from contextlib import contextmanager

log = []

@contextmanager
def observing_session(target):
    log.append(f"open {target}")
    try:
        yield target
    finally:
        log.append(f"close {target}")

with observing_session("Venus"):
    log.append("observe Venus")

try:
    with observing_session("Mars"):
        raise RuntimeError("tracking motor failed")
except RuntimeError as error:
    log.append(f"error: {error}")

print(log)

['open Venus', 'observe Venus', 'close Venus', 'open Mars', 'close Mars', 'error: tracking motor failed']

"close Mars" appears before the error is handled outside, proving the clean-up ran first. For the worked check, essential @contextmanager clean-up goes in finally around yield.

The language reference explains the with statement, and contextlib documents contextmanager, suppress and ExitStack. Continue with the file lifecycle and revisit error handling. Practise with the Python exercises and Python quiz.