Python Closures

3Python Closures: explained step by step

In the scope lesson you saw that a function defined inside another function can read the outer function's variables. This lesson is about what happens when that inner function leaves the place where it was born. Python keeps the variables it needs alive, and the result is a closure: a function bundled together with the values it remembers from the scope around it.

A function that remembers

def make_greeter(greeting):
    def greet(name):
        return f"{greeting}, {name}!"
    return greet                 # return the function itself: no parentheses

hello = make_greeter("Hello")
hola = make_greeter("Hola")
print(hello("Asha"))
print(hola("Ben"))

make_greeter is finished as soon as it returns, and normally its local variables would disappear with it. But greet still needs greeting, so Python keeps that value alive and attaches it to the function. hello and hola are two separate greet functions, each remembering its own greeting.

Pay attention to the last line of make_greeter. return greet hands back the function. return greet("x") would call it and hand back the text instead.

Free variables

Inside greet, the name name is local because it is a parameter. But greeting is neither local nor global: it belongs to the enclosing function. A name used in a function but defined in an enclosing scope is called a free variable, and a function with at least one free variable is a closure.

Function factories

A function that builds and returns other functions is a factory. You give it the settings once, and it hands back a specialised function you can call as often as you like:

def make_multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10), triple(10))
print(list(map(triple, [1, 2, 3])))

Because triple takes one argument, it plugs straight into map(), filter() or sorted(key=...). A lambda that uses an outer variable, like lambda n: n * factor, is a closure too.

State that survives between calls

A closure can also change what it remembers, which gives you a function with a memory. Because count += 1 is an assignment, Python would normally treat count as a new local variable and fail. The nonlocal keyword says "this name belongs to the enclosing function":

def make_counter():
    count = 0
    def step():
        nonlocal count           # change the enclosing variable, do not make a new one
        count += 1
        return count
    return step

page_views = make_counter()
downloads = make_counter()
print(page_views(), page_views(), page_views())
print(downloads())

Each call to make_counter() creates a fresh count, so the two counters never disturb each other. You only need nonlocal when you reassign the name. Changing an object it points to, such as scores.append(80) on a remembered list, needs no keyword.

Closure or class?

A class can hold the same state, and sometimes it is the better choice:

class Counter:
    def __init__(self):
        self.count = 0

    def step(self):
        self.count += 1
        return self.count

page_views = Counter()
print(page_views.step(), page_views.step())
print(page_views.count)          # a class lets anyone read the state

A closure suits one small behaviour with a little private state, and nobody outside can touch count. Write a class once you need several methods, attributes people should read, or something other developers will extend.

Why not just use a global variable?

A global count would also survive between calls, but there is only one of it. Two counters would need two globals and two almost identical functions, and any code anywhere could change them by accident. A closure gives every function its own private copy, created on demand.

Peeking inside with __closure__

Python stores each remembered variable in a small cell. You will rarely need this outside of learning and debugging, but it makes the idea concrete:

def make_counter():
    count = 0
    def step():
        nonlocal count
        count += 1
        return count
    return step

tally = make_counter()
tally()
tally()
print(tally.__code__.co_freevars)
cell = tally.__closure__[0]
print(cell.cell_contents)
tally()
print(cell.cell_contents)

def plain(x):
    return x

print(plain.__closure__)

co_freevars lists the remembered names, and cell_contents shows the live value. The cell changes when the function changes it. An ordinary function with no free variables has __closure__ set to None.

The loop gotcha: late binding

A closure remembers the variable, not the value the variable had when the function was created. In a loop, every function shares the same variable, and by the time you call them it holds the last value:

def make_greeters(names):
    late = []
    early = []
    for name in names:
        late.append(lambda: f"Hi {name}")
        early.append(lambda name=name: f"Hi {name}")
    return late, early

late, early = make_greeters(["Asha", "Ben", "Cara"])
print([g() for g in late])
print([g() for g in early])

The first list says Cara three times. The second works because a default argument is evaluated when the lambda is created, so each function gets its own copy. Another fix is to build each function inside a small factory, so every call has its own variable.