Context Managers in Python

# Without context manager — fragile cleanup

f = open("data.txt", "w")
f.write("some data")
f.close()   # fine if nothing goes wrong

# If an exception occurs before close(), the file stays open forever
f = open("data.txt", "w")
try:
    f.write("some data")
    raise ValueError("something went wrong")   # simulated error
finally:
    f.close()   # must wrap everything in try/finally to guarantee cleanup
    print("File closed in finally block")

# with statement — guaranteed setup and teardown

with open("data.txt", "w") as f:
    f.write("Hello from context manager!")
# f.close() is called automatically here — exception or not

with open("data.txt", "r") as f:
    content = f.read()
    print(content)

# Multiple context managers on one line (Python 3.1+)
with open("input.txt", "w") as inp, open("output.txt", "w") as out:
    inp.write("input data")
    out.write("output data")
    print("Both files written and closed automatically.")

# Python 3.10+ parenthesised form — cleaner for 3+ managers
# with (
#     open("a.txt") as a,
#     open("b.txt") as b,
# ): ...

class ManagedFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode     = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        print(f"Opened: {self.filename}")
        return self.file            # bound to the 'as' variable

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        print(f"Closed: {self.filename}")
        if exc_type:
            print(f"Exception handled: {exc_val}")
        return False   # False = let exception propagate (normal default)

# Normal use — no exception
with ManagedFile("notes.txt", "w") as f:
    f.write("context managers are great")
    print("Write done.")

# Exception inside the block — __exit__ still runs
try:
    with ManagedFile("notes.txt", "a") as f:
        raise ValueError("oops!")
except ValueError:
    print("Exception propagated (return False in __exit__)")

from contextlib import contextmanager

@contextmanager
def managed_file(filename, mode):
    print(f"Opening: {filename}")
    f = open(filename, mode)
    try:
        yield f           # value bound to the 'as' variable
    except Exception as e:
        print(f"Exception inside block: {e}")
        raise             # re-raise — don't suppress
    finally:
        f.close()         # always runs
        print(f"Closed: {filename}")

with managed_file("notes.txt", "w") as f:
    f.write("generator-based context manager")
    print("Write done.")

import time, os
from contextlib import contextmanager

@contextmanager
def timer(label="block"):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label} took {elapsed:.4f}s")

@contextmanager
def change_dir(path):
    original = os.getcwd()
    os.chdir(path)
    try:
        yield
    finally:
        os.chdir(original)   # always restore — even on exception

with timer("Sum of range"):
    result = sum(range(5_000_000))
    print("Result:", result)

print("Before:", os.getcwd())
with change_dir("/tmp"):
    print("Inside:", os.getcwd())
print("After:", os.getcwd())

from contextlib import suppress, redirect_stdout, nullcontext, closing
import io

# suppress — silently ignore specific exceptions
with suppress(FileNotFoundError):
    open("nonexistent.txt")
print("Carried on after missing file")

# redirect_stdout — capture print() output into a string
buffer = io.StringIO()
with redirect_stdout(buffer):
    print("this goes to the buffer")
print("Captured:", buffer.getvalue().strip())

# nullcontext — no-op, useful when a context manager is optional
debug_mode = False
ctx = timer("block") if debug_mode else nullcontext()
with ctx:
    x = sum(range(100))

# closing — wraps any object with .close() in a context manager
class Resource:
    def close(self): print("Resource closed")
    def use(self): print("Resource in use")

with closing(Resource()) as r:
    r.use()