with, yield, and the two protocols underneath

Two pieces of syntax that are really protocols. Both appear everywhere in the code you are about to read, and both are things you can implement on your own types with two methods.

with: guaranteed cleanup, owned by the resource

with open("data.json") as f:
    payload = json.load(f)
# f is closed here, no matter how we left the block

with x as y: calls x.__enter__() and binds its return value to y. On leaving the block, by any path at all, it calls x.__exit__(exc_type, exc_value, traceback).

Every path: normal completion, return, break, or an unhandled exception. It is try/finally with the cleanup living on the object instead of at every call site.

You will meet these constantly:

with open(path) as f: ...                          # files
with httpx.Client() as client: ...                 # connection pooling
with Session(engine) as session: ...               # database transactions
with tempfile.TemporaryDirectory() as d: ...       # scratch space, cleaned up
with lock: ...                                     # threading locks
with pytest.raises(ValueError): ...                # asserting a raise

That last one is a nice illustration of how general the protocol is: pytest.raises uses __exit__ to inspect the exception and fail the test if the expected one did not appear. __exit__ can return a truthy value to suppress the exception entirely, which is a real power and one almost nothing should use.

Writing one

class Timer:
    def __enter__(self):
        self.start = time.monotonic()
        return self
    def __exit__(self, *exc):
        self.elapsed = time.monotonic() - self.start
        return False          # do not suppress

# or, far more often:
from contextlib import contextmanager

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

The generator form is the one you will read. Before the yield is setup, the yielded value is what as binds, after the yield is teardown. The try/finally is not optional decoration: without it, an exception in the block propagates straight out of the yield and the teardown never runs.

You can also stack them, and a trailing comma is legal in the parenthesised form:

with open(src) as fin, open(dst, "w") as fout:
    fout.write(fin.read())

yield: functions that pause

def read_lines(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

A function containing yield is a generator function. Calling it runs none of the body: it builds a generator object and returns immediately. The body advances only when something asks for a value, runs until the next yield, hands the value over, and freezes there with its local state intact.

That laziness is the point. read_lines on a four-gigabyte file uses a few kilobytes of memory, and a consumer that stops after ten lines never reads the eleventh.

for line in read_lines("big.log"):     # pulls one at a time
    if "ERROR" in line:
        print(line)

lines = list(read_lines("small.log"))  # forces the whole thing
total = sum(1 for _ in read_lines(p))  # counts without materialising

The generator expression from module 1 is the same object with less ceremony: (x * 2 for x in nums) is lazy, single-use, and exactly what yield produces.

yield from, briefly

def all_lines(paths):
    for p in paths:
        yield from read_lines(p)

yield from delegates to another iterable and yields everything it produces. Without it you would write a nested loop that re-yields each item, which is what people do before they learn this exists.

Where you will meet both in agent code

Streaming is generators, and resource lifetimes are context managers.

for chunk in graph.stream(state, config):   # a generator: chunks as they arrive
    render(chunk)

with checkpointer_context() as saver:       # a context manager: connection lifetime
    graph = builder.compile(checkpointer=saver)

The streaming APIs across LangChain and LangGraph are generators (and their async equivalents, which is the next lesson). Every connection-holding object in the ecosystem is a context manager, and using one outside a with is the standard way to leak a Postgres connection.

The iterator protocol underneath

Both of these are just dunders, which is the module 1 lesson arriving with consequences.

• for x in thing calls thing.__iter__() to get an iterator, then __next__() repeatedly until StopIteration.
• with thing calls __enter__ and __exit__.

Implement the methods and your own class works with the syntax. There is nothing to inherit and nothing to declare, which is why the standard library composes as freely as it does: zip, enumerate, sorted, sum, any, all and every function in itertools work on anything iterable, including things written after they were.

Where this goes

One idiom left, and it is the one with the most surface area: async. The syntax is identical to what you already write and the runtime underneath is meaningfully different from Node’s.