Core Python Programming (2nd Edition)

If references are made from inside an inner function to an object defined in any outer scope (but not in
the global scope), the inner function then is known as a closure. The variables defined in the outer
function but used or referred to by the inner function are called free variables. Closures are an important
concept in functional programming languages, with Scheme and Haskell being two of them. Closures are
syntactically simple (as simple as inner functions) yet still very powerful.
A closure combines an inner function's own code and scope along with the scope of an outer function.
Closure lexical variables do not belong to the global namespace scope or the local onethey belong to
someone else's namespace and carry an "on the road" kind of scope. (Note that they differ from objects
in that those variables live in an object's namespace while closure variables live in a function's
namespace and scope.) So why would you want to use closures?
Closures are useful for setting up calculations, hiding state, letting you move around function objects
and scope at will. Closures come in handy in GUI or event-driven programming where a lot of APIs
support callbacks. The same applies for retrieving database rows and processing the data in the exact
same manner. Callbacks are just functions. Closures are functions, too, but they carry some additional
scope with them. They are just functions with an extra feature ... another scope.
You will probably feel that the use of closures draws a strong parallel to partial function application as
introduced earlier in this chapter, but PFA is really more like currying than the use of closures because it
is not as much as about function calling as it is about using variables defined in another scope.
Simple Closure Example
Below is a short example of using closures. We will simulate a counter and also simulate making an
integer mutable by enclosing it as a single element of a list.
def counter(start_at=0):
count = [start_at]
def incr():
count[0] += 1
return count[0]
return incr
The only thing counter() does is to accept an initial value to start counting at and assigns it as the sole
member of the list count. Then an incr() inner function is defined. By using the variable count inside it,
we have created a closure because it now carries with it the scope of counter(). incr() increments the
running count and returns it. Then the final magic is that counter() returns incr, a (callable) function
object.
If we run this interactively, we get the output belownote how similar it looks to instantiating a counter
object and executing the instance:
>>> count = counter(5)
>>> print count()
6
>>> print count()
7