What Are Closures in Python?

A closure is a function that keeps access to the variables of the scope where it was defined, even after that scope has finished running.

Consider a factory function that creates a counter variable, defines a nested increment function that reads and updates it, and then returns that nested function. When the factory returns, its local scope normally disappears — but the nested function holds a reference to it, so the counter variable stays alive. Each call to the returned function reads and updates that same cell, which is why the counter climbs rather than restarting at zero every time.

The keyword that makes this work is nonlocal. Without it, the statement that updates the counter inside the nested function would be treated as creating a new local variable, and Python would raise an UnboundLocalError. With it, the nested function is explicitly allowed to rebind the name from the enclosing scope.

Two practical points to raise in an interview. A closure keeps its captured variables alive for as long as the closure object exists, so storing closures in a long-lived data structure can keep a surprising amount of memory alive. And closures are the foundation of decorators, of callbacks and of many functional patterns, because they let a function carry context without needing a class.

A closure over a loop variable captures the variable, not its value at the time the closure was created. That is late binding, and it produces a surprising result.

def make_adders():
    adders = []
    for number in range(3):
        adders.append(lambda n: n + number)
    return adders


adders = make_adders()
print([adder(10) for adder in adders])   # [12, 12, 12]


def make_adders_fixed():
    adders = []
    for number in range(3):
        adders.append(lambda n, number=number: n + number)
    return adders


print([adder(10) for adder in make_adders_fixed()])   # [10, 11, 12]

All three adders in the first list return 12. The reason is that there is one variable called number in the enclosing scope, and all three lambdas close over that same variable. By the time you call the adders, the loop has finished and number holds 2, so every adder adds 2.

The fix is to give each lambda its own value of number, and the default-argument trick does exactly that. The default is evaluated when the lambda is created, so each one captures its own copy, and the adders now return 10, 11 and 12.

There are two other ways to solve it, and both are worth knowing. Calling the lambda immediately with an extra argument — adder(n, number) — works because it evaluates number at that moment. And using a factory function, as in the fixed version, is the cleanest of all: one extra function call per iteration, but no default-argument trickery to explain.