Closure

What is closure?

Short answer may be like this: a closure is a combination of code and scope. Python functions are a combination of code to be executed and the scope in which to execute them. However, most of the time when we speak about closure, it's about nested function and the scope of the function. Sometimes we want a function to retain a value when it was created even though the scope cease to exist. This technique of using the values of outer parameters within a dynamic function is another way of defining the closure.

Let's think about the behavior of the function objects in the following code:

def startAt(start):
	def incrementBy(inc):
		return start + inc
	return incrementBy

f = startAt(10)
g = startAt(100)

print f(1), g(2)

Closures in python are created by function calls. In the code above, the call to startAt() creates a binding for start that is referenced inside the function incrementBy(). Each call to startAt() creates a new instance of this function, but each instance has a link to a different binding of start.

If we run it:

11 102

So, it looks like the call objects f and g retain their states at the time they were created. When we create f, the outer function startAt() uses the nested function incrementBy() as a return value. Note that it's the function itself that is returned, not the return value of that function. The inner function is not called within the startAt() function. So, the startAt() is a function that returns a function when called. In that way, our program can have an external reference to the nested function, and the nested function retains its reference to the call object of the outer function. In that way, the call object for a particular invocation of the outer function continues to live.

In summary, a closure is a function (object) that remembers its creation environment (enclosing scope).

def startAt(start):
    def incrementBy(inc):
        return start + inc
    return incrementBy

closure1 = startAt(10)
closure2 = startAt(100)
print 'clsure1(3) = %s' %(closure1(3))
print 'closure2(3) = %s' %(closure2(3))

Output:

clsure1(3) = 13
closure2(3) = 103

Invoking the variable closure1 (which is of function type) with closure1(3) will return 13, while invoking closure2(3) will return 103. While closure1 and closure2 are both references to the function incrementBy, the associated environment will bind the identifier start to two distinct variables in the two invocations, leading to different results.

We can get more info using __closure__ attribute and cell objects:

def startAt(start):
	def incrementBy(inc):
		return start + inc
	return incrementBy

f = startAt(10)
g = startAt(100)

print 'type(f)=%s' %(type(f))
print 'f.__closure__=%s' %(f.__closure__)
print 'type(f.__closure__[0])=%s' %(type(f.__closure__[0]))
print 'f.__closure__[0].cell_contents=%s' %(f.__closure__[0].cell_contents)

print 'type(g)=%s' %(type(g))
print 'g.__closure__=%s' %(g.__closure__)
print 'type(g.__closure__[0])=%s' %(type(g.__closure__[0]))
print 'g.__closure__[0].cell_contents=%s' %(g.__closure__[0].cell_contents)

From the output below, we can see each cell of the objects retains the value at the time of its creation:

type(f)=<type 'function'>
f.__closure__=<cell at 0x7f9a18e8ca60: int object at 0x1a0d170>
type(f.__closure__[0])=<type 'cell'>
f.__closure__[0].cell_contents=10
type(g)=<type 'function'>
g.__closure__=<cell at 0x7f9a18e8cbe8: int object at 0x1a0d080>
type(g.__closure__[0])=<type 'cell'>
g.__closure__[0].cell_contents=100

Just want to remind you of the fact: "Many functional languages rely heavily on closures."

Let's switch the name of the inner function:

def startAt(start):
	def invisible(inc):
		return start + inc
	return invisible

f = startAt(10)
g = startAt(100)

As the new name suggested the name of the nested function is invisible to the outside. So, if that's the case, we can use anonymous lambda function like this:

def startAt(start):
	return lambda inc: start+inc


f = startAt(10)
g = startAt(100)

print f(1), g(2)

It still gives us the same result!