File I/O & Context Managers

with open("data.txt") as f:
    content = f.read()
print(content)
# file is automatically closed here, even if .read() had raised an exception

Common follow-ups: What exception type does open() raise if the specified file doesn't exist?

with open("data.txt") as f:
    all_content = f.read()        # one big string

with open("data.txt") as f:
    first_line = f.readline()      # just one line

with open("data.txt") as f:
    lines = f.readlines()          # a list of every line

Common follow-ups: How does iterating directly over the file object (for line in f) compare to calling readlines()?

with open("log.txt", "a") as f:
    f.write("New log entry\n")  # appends, doesn't erase existing content

with open("image.png", "rb") as f:
    data = f.read()  # returns bytes, not a decoded string

Common follow-ups: What happens if you open a file with 'w' mode and the file already contains important data?

class Timer:
    def __enter__(self):
        self.start = time.time()
        return self
    def __exit__(self, exc_type, exc_value, tb):
        elapsed = time.time() - self.start
        print(f"Took {elapsed:.2f}s")

with Timer():
    do_expensive_work()

Common follow-ups: What should __exit__ return if you want an exception raised inside the 'with' block to still propagate normally?

from contextlib import contextmanager
import time

@contextmanager
def timer():
    start = time.time()
    try:
        yield
    finally:
        print(f"Took {time.time() - start:.2f}s")

with timer():
    do_expensive_work()

Common follow-ups: Why must the yield inside a @contextmanager-decorated generator typically be wrapped in a try/finally?

from pathlib import Path

data_dir = Path("data")
file_path = data_dir / "input.txt"  # '/' operator joins paths cleanly
print(file_path.exists())            # True/False
print(file_path.suffix)              # '.txt'
print(file_path.read_text())          # reads the entire file as a string, no 'with' needed

Common follow-ups: How does Path.read_text() internally handle opening and closing the file, compared to a manual 'with open()' block?

with open("input.txt") as infile, open("output.txt", "w") as outfile:
    for line in infile:
        outfile.write(line.upper())
# both files properly closed, even nested exceptions are handled correctly

Common follow-ups: In what order are the context managers' __exit__ methods called if an exception occurs partway through the block?

import os
from contextlib import contextmanager

@contextmanager
def temporary_directory(path):
    original = os.getcwd()
    os.chdir(path)
    try:
        yield
    finally:
        os.chdir(original)  # always restored, even on exception

with temporary_directory("/tmp"):
    process_files_here()
# working directory is back to the original, guaranteed

Common follow-ups: Why is this pattern particularly risky to implement WITHOUT a context manager, in terms of leaking the directory change on error?

from contextlib import ExitStack

filenames = ["a.txt", "b.txt", "c.txt"]
with ExitStack() as stack:
    files = [stack.enter_context(open(fname)) for fname in filenames]
    for f in files:
        process(f)
# ALL files are properly closed here, however many there were

Common follow-ups: How does ExitStack's callback() method let you register arbitrary cleanup functions, not just full context managers?

from contextlib import contextmanager

@contextmanager
def suppress_and_log(*exceptions):
    try:
        yield
    except exceptions as e:
        logging.warning(f"Suppressed: {e}")

@suppress_and_log(ValueError)
def risky_operation():
    raise ValueError("oops")

risky_operation()  # logs a warning instead of crashing, thanks to decorator usage

Common follow-ups: What is the specific base class (ContextDecorator) that enables this dual with/decorator usage pattern?