In Python, cell
objects are used to store the free variables of a closure.
Let's say you want a function that always returns a particular fraction of its argument. You can use a closure to achieve this:
def multiplier(n, d):
"""Return a function that multiplies its argument by n/d."""
def multiply(x):
"""Multiply x by n/d."""
return x * n / d
return multiply
And here's how you can use it:
>>> two_thirds = multiplier(2, 3)
>>> two_thirds(7)
4.666666666666667
How does two_thirds
remember the values of n
and d
? They aren't arguments to the multiply
function that multiplier
defined, they aren't local variables defined inside multiply
, they aren't globals, and since multiplier
has already terminated, its local variables no longer exist, right?
What happens is that when multiplier
is compiled, the interpreter notices that multiply
is going to want to use its local variables later, so it keeps a note of them:
>>> multiplier.__code__.co_cellvars
('d', 'n')
Then when multiplier
is called, the value of those outer local variables is stored in the returned function's __closure__
attribute, as a tuple of cell
objects:
>>> two_thirds.__closure__
(<cell at 0x7f7a81282678: int object at 0x88ef60>,
<cell at 0x7f7a81282738: int object at 0x88ef40>)
... with their names in the __code__
object as co_freevars
:
>>> two_thirds.__code__.co_freevars
('d', 'n')
You can get at the contents of the cells using their cell_contents
attribute:
>>> {v: c.cell_contents for v, c in zip(
two_thirds.__code__.co_freevars,
two_thirds.__closure__
)}
{'d': 3, 'n': 2}
You can read more about closures and their implementation in the Python Enhancement Proposal which introduced them: PEP 227 — Statically Nested Scopes.