How do you make a lambda created inside a for loop capture that iteration's value?

The question is really "how do I create a **per-iteration binding**?", because that is the only thing that separates the working versions from the broken one. A function defined in a loop reads its free variables when it is called; the loop variable is a single variable that keeps moving, so every callable sees the same final value. Python hands out fresh bindings on a **call**, in the shape of parameters — so every fix is a way of making the loop value a parameter of something. ### 1. A default parameter ```python handlers = [lambda v=v: v * 2 for v in range(3)] print([h() for h in handlers]) # [0, 2, 4] ``` Default values are evaluated **once, when the function object is created** — which, inside a loop, means once per iteration with the current value. The value is stored on that function object (visible as `__defaults__`), and inside the body the parameter shadows the enclosing name, so the closure lookup never happens. Strengths: shortest to write, no extra names, obvious once you know the idiom. Weaknesses: the parameter is part of the public signature. `inspect.signature` shows `(v=0)`, and any caller can pass a different value — accidentally or through a framework that inspects the signature and decides to fill it. It is also unusable when the callable must match a fixed signature that already uses that position. Treat it as fine for local, throwaway lambdas and questionable for a callable you hand to someone else. ### 2. `functools.partial` ```python from functools import partial def scale(v): return v * 2 handlers = [partial(scale, v) for v in range(3)] print([h() for h in handlers]) # [0, 2, 4] ``` `partial` records the argument when the partial object is created and supplies it when the object is called. Two properties matter here: the bound value is captured eagerly, so the loop variable is irrelevant afterwards; and the real work lives in a normal named function that can be imported, tested and profiled on its own. The bound arguments stay introspectable on the partial object, which helps when you are debugging a registry of hundreds of callables. ### 3. A factory function ```python def make_handler(v): def handler(): return v * 2 return handler handlers = [make_handler(v) for v in range(3)] ``` The outer call creates a new local `v` per iteration, and the inner function closes over *that* — a different variable each time, so late binding is harmless. This is the most explicit form and the one to reach for when the inner function is more than one expression, needs a docstring, or needs a name in tracebacks. ### What does not fix it * **Using `def` instead of `lambda`.** They build the same kind of function object with the same closure rules. A nested `def` in a loop body captures the loop variable exactly as a lambda does. Syntax is not the issue. * **Copying the value to another name in the loop.** `w = v` puts another variable in the same scope; it also ends at the last value. * **Copying the list or the container being iterated.** The container was never the problem. * **Calling the functions "sooner".** That hides the bug rather than fixing it, and it stops being true the moment the callables are deferred again. ### Choosing between them For a quick local list of lambdas, the default parameter is idiomatic and everybody recognizes it. For anything registered, stored, or handed to a framework, prefer `functools.partial` or a factory: the value is bound without lying about the signature, the underlying function is testable on its own, and a reviewer can see the binding in one line. In a codebase where this bug has already happened once, the durable fix is structural — give the registration function a parameter for the per-iteration value, so the loop body has nothing to close over and the mistake becomes impossible to write. ### One more nuance `nonlocal` and `global` do not enter into this. They change *where a name is rebound*, not *when it is read*; a closure over a `nonlocal` variable is still late-binding. The fix is always a new binding per iteration, and in Python that means a call with a parameter.