Python Context Managers – with Statement and __enter__/__exit__

The with Statement

with ensures the resource is properly closed/released regardless of what happens.

# Without context manager (bad — file may not close on error)
f = open("data.txt", "w")
f.write("Hello")  # If this crashes, f.close() never runs!
f.close()

# With context manager (correct)
with open("data.txt", "w") as f:
    f.write("Hello")  # __exit__ calls f.close() automatically
# File is closed here — always

The Context Manager Protocol

Any class with __enter__ and __exit__ works as a context manager.

class Timer:
    import time as _time

    def __enter__(self):
        import time
        self.start = time.time()
        return self   # Bound to "as" variable

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        elapsed = time.time() - self.start
        print(f"Elapsed: {elapsed:.4f}s")
        return False  # Don't suppress exceptions

with Timer() as t:
    total = sum(range(1_000_000))

contextlib.contextmanager – Generator Approach

Use @contextmanager to write context managers as generator functions — less boilerplate.

from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    print(f"Opening {name}")
    try:
        yield name      # Everything before yield = __enter__
    finally:
        print(f"Closing {name}")  # Always runs = __exit__

with managed_resource("database") as r:
    print(f"Working with {r}")

Multiple Context Managers

Combine multiple managers in one with statement.

# Open two files simultaneously
with open("input.txt", "r") as src, open("output.txt", "w") as dst:
    for line in src:
        dst.write(line.upper())

# Both files auto-closed after block

contextlib.suppress – Ignore Specific Exceptions

Cleanly suppress known safe exceptions without try/except.

from contextlib import suppress
import os

# Instead of:
try:
    os.remove("temp.txt")
except FileNotFoundError:
    pass

# Use suppress:
with suppress(FileNotFoundError):
    os.remove("temp.txt")

Why with Guarantees Cleanup — Even When Code Crashes

A context manager runs setup on entry and teardown on exit no matter what — normal finish, early return, or an exception all trigger the cleanup. That's why with open(...) is safer than a bare open(): the file closes even if the code inside blows up.

# Without: a crash before close() leaks the file handle
f = open("data.txt")
process(f)          # if this raises, f is never closed
f.close()

# With: __exit__ runs on the way out, exception or not
with open("data.txt") as f:
    process(f)      # file guaranteed closed afterward

Build your own two ways

# 1) class with __enter__ / __exit__
class Timer:
    def __enter__(self): self.t = time.time(); return self
    def __exit__(self, *exc): print(time.time() - self.t)

# 2) the shortcut: contextlib
from contextlib import contextmanager
@contextmanager
def timer():
    t = time.time()
    yield                 # everything before = enter, after = exit
    print(time.time() - t)

__exit__ receives the exception info; return True from it to swallow the error, or None/False to let it propagate. Stack multiple: with A() as a, B() as b: closes them in reverse order.

Interview Questions on Context Managers

• What is a context manager and what problem does it solve?
• How does the with statement work under the hood?
• What methods make up the context manager protocol?
• How do you create a context manager using contextlib.contextmanager?
• What does the return value of __exit__ control?
• How do you manage multiple resources in one with block?
• What does contextlib.suppress do?

Related Topics