What Does the with Statement Do?

The with statement runs a block and guarantees the resource is released when the block ends, whether it ended normally or with an exception.

import os
import tempfile

path = os.path.join(tempfile.gettempdir(), "tutorsbot_with.txt")

with open(path, "w", encoding="utf-8") as handle:
    handle.write("hello with\n")

print(handle.closed)          # True - closed when the block ended

with open(path, encoding="utf-8") as handle:
    print(handle.read().strip())

os.remove(path)

The first line is the point of the whole construct. After the with block, the file object's closed attribute is True, and that is true even if an exception had been raised inside the block — the file would still be closed, and the exception would still propagate.

Behind the syntax, the file object is a context manager. It implements __enter__, which returns the resource to bind to the target name, and __exit__, which is called when the block finishes. The with statement is really just a tidier way of writing a try/finally pair.

You can write your own context managers, and the class-based form is worth recognising.

class Managed:
    def __enter__(self):
        print("enter")
        return self

    def __exit__(self, exc_type, exc, tb):
        print("exit")
        return False         # do not suppress exceptions


with Managed():
    print("body")

The output is enter, body, exit. The value returned by __exit__ decides whether an exception is swallowed — returning False, or None, lets it propagate, while returning True suppresses it.

The with statement calls the __enter__ method on a context manager, binds the result to the target name, runs the block, and then calls __exit__ on the manager — even if the block raised an exception. The exception is then re-raised unless __exit__ returns True.

That guarantee is the whole point. The manual equivalent is a try/finally, and the with statement is a tidier way of writing it that also handles the setup and cleanup in one place. For a file, the file is opened before the block and closed after it, so you cannot forget the close and you cannot leak the file handle when an exception escapes.

The keyword statement was added in Python 2.5 and is now used far beyond files. Locks use it so the lock is always released. The contextlib module provides contextmanager, which turns any generator function into a context manager — the code before the yield is the setup and the code after it is the cleanup. And the standard library ships many context managers of its own, including redirect_stdout, suppress, closing and the newer contextlib.chdir.

Two details worth knowing for an interview. A with statement can hold several context managers at once, separated by commas, and they are entered left to right and exited right to left. And since Python 3.1 you can write asynchronous context managers with async with, which is how async database connections and session scopes are handled in asyncio code.