Closures and Captured Variables

20 min · Intermediate

A function can be built inside another function and keep using the outer function's variables after it has finished. This idea, the closure, is the base of decorators.

Functions are values

First-class function means a function is an ordinary value: you can assign it to a name, store it in a collection, pass it as an argument and return it from another function.

In Python a function is an object. You can store it in a variable or a dictionary, pass it to another function, and return it from one.

Python

1def double(x):2    return x * 23
4def apply(func, value):5    return func(value)6
7ops = {"double": double, "negate": lambda x: -x}8print(apply(double, 5))9print(ops["negate"](4))

Example 1 · Functions as values

Python

1def apply_tax(price):2    return round(price * 1.18, 2)3
4def apply_discount(price):5    return price * 0.96
7steps = [apply_discount, apply_tax]8price = 10009for step in steps:10    price = step(price)11print(price)

Output

1062.0

What this code does

A list can hold functions, and a loop can call them in turn.
The result is 1000 reduced by 10 percent, then raised by 18 percent.

apply does not care which function it gets. It just calls it.

A closure remembers its surroundings

Closure is an inner function together with the variables it uses from the enclosing function. The variables stay available after the outer function has returned.

When an inner function uses a variable of the outer function, Python keeps that variable alive for it. The inner function plus those kept variables is a closure.

Python

1def make_discount(percent):2    def apply(price):3        return price * (100 - percent) / 1004    return apply5
6ten_off = make_discount(10)7print(ten_off(200))8print(ten_off.__closure__[0].cell_contents)

Two calls to make_discount create two separate inner functions. ten_off holds a cell with percent = 10 and twenty_off holds a cell with percent = 20. Each inner function reads only its own cell.

Example 2 · Two closures, two memories

Python

1def make_discount(percent):2    def apply(price):3        return price * (100 - percent) / 1004    return apply5
6ten_off = make_discount(10)7twenty_off = make_discount(20)8print(ten_off(500), twenty_off(500))

Output

450.0 400.0

What this code does

Each call to make_discount creates a new apply with its own percent.
The two functions do not share anything.

make_discount has finished, yet ten_off still knows percent. Each call to make_discount makes a separate closure with its own value.

nonlocal lets an inner function change state

nonlocal is a statement that tells Python an assigned name belongs to the nearest enclosing function, not to the current one.

An inner function can read an outer variable freely. To assign to it, declare it nonlocal. Without that, the assignment makes a new local variable.

Python

1def make_counter():2    count = 03
4    def next_id():5        nonlocal count6        count += 17        return count8
9    return next_id10
11ticket = make_counter()12print(ticket(), ticket(), ticket())

Example 3 · A counter with nonlocal

Python

1def make_counter():2    count = 03
4    def next_id():5        nonlocal count6        count += 17        return count8
9    return next_id10
11orders = make_counter()12invoices = make_counter()13print(orders(), orders(), invoices())

Output

1 2 1

What this code does

orders and invoices each keep their own count.
Remove the nonlocal line and the call raises UnboundLocalError.

Example 4 · A closure that does the job of a class

Python

1def make_account(balance):2    def deposit(amount):3        nonlocal balance4        balance += amount5        return balance6    return deposit7
8deposit = make_account(100)9print(deposit(50))10print(deposit(25))

Output

150
175

What this code does

The balance lives in the closure, hidden from outside code.
A class with self.balance does the same job and is easier to grow with more methods.

Each call to make_counter() starts its own count, so two counters never disturb each other.

The late-binding trap in loops

Late binding means a closure looks up a variable's value when the function is called, not when it was created.

A closure captures the variable, not its value at that moment. Functions made in a loop all see the final value of the loop variable. A default argument freezes the current value.

Python

broken = [lambda: i for i in range(3)]fixed = [lambda i=i: i for i in range(3)]print([f() for f in broken])print([f() for f in fixed])

Example 5 · Fixing the late-binding trap

Python

multipliers = [lambda x, n=n: x * n for n in (2, 3, 4)]print([f(10) for f in multipliers])
broken = [lambda x: x * n for n in (2, 3, 4)]print([f(10) for f in broken])

Output

[20, 30, 40]
[40, 40, 40]

What this code does

The default n=n stores each loop value inside its own function.
The broken version multiplies every time by 4, the last loop value.

All three broken functions read the same i, which is 2 when they are finally called. In fixed, each function has its own default.

Next step

Check your understanding

12 quick questions

Functions are values

First-class function means a function is an ordinary value: you can assign it to a name, store it in a collection, pass it as an argument and return it from another function.

In Python a function is an object. You can store it in a variable or a dictionary, pass it to another function, and return it from one.

1def apply_tax(price):2 return round(price * 1.18, 2)3 4def apply_discount(price):5 return price * 0.96 7steps = [apply_discount, apply_tax]8price = 10009for step in steps:10 price = step(price)11print(price)

A closure remembers its surroundings

Closure is an inner function together with the variables it uses from the enclosing function. The variables stay available after the outer function has returned.

When an inner function uses a variable of the outer function, Python keeps that variable alive for it. The inner function plus those kept variables is a closure.

1def make_discount(percent):2 def apply(price):3 return price * (100 - percent) / 1004 return apply5 6ten_off = make_discount(10)7print(ten_off(200))8print(ten_off.__closure__[0].cell_contents)

1def make_discount(percent):2 def apply(price):3 return price * (100 - percent) / 1004 return apply5 6ten_off = make_discount(10)7twenty_off = make_discount(20)8print(ten_off(500), twenty_off(500))

1def make_counter():2 count = 03 4 def next_id():5 nonlocal count6 count += 17 return count8 9 return next_id10 11ticket = make_counter()12print(ticket(), ticket(), ticket())

1def make_counter():2 count = 03 4 def next_id():5 nonlocal count6 count += 17 return count8 9 return next_id10 11orders = make_counter()12invoices = make_counter()13print(orders(), orders(), invoices())

1def make_account(balance):2 def deposit(amount):3 nonlocal balance4 balance += amount5 return balance6 return deposit7 8deposit = make_account(100)9print(deposit(50))10print(deposit(25))