高阶函数中的闭包魔术。

Question

It's easy to know how to assign a global variable to an inner function - which would make the global variable a function itself thats equal to the inner function - but how does the interpreter know how to call an argument from the inner function by using the code below?

def outer(arg):
    def inner(arg2):
        print(arg, ',', arg2):
    return inner

a = outer(‘outer arg’)

print(a) # .inner at 0x109bd0048
a('inner arg') # Output: outer arg, inner arg

Doing print(a) , we see the variable/function a becomes the inner function.

What I don't understand, is how assigning the a variable to the outer function targets the inner function and argument with the code, a('inner argument'))

Is it somehow implicitly calling the inner function without explicitly stating it?

Is it doing something like this:

a = outer('outer arg')inner('inner arg')

Where is the python source code behind this magic?

Answer 1

I don't have enough reputation for a comment, so I have to write an answer...

From the excellent "Fluent Python" by Luciano Ramalho:

"...Python keeps the names of local and free variables in the __code__ attribute that represents the compiled body of the function"

"To summarize: a closure is a function that retains the bindings of the free variables that exist when the function is defined, so that they can be used later when the function is invoked and the defining scope is no longer available"

I added a couple of rows to your code to visualize this:

def outer(arg):
    def inner(arg2):
        print(arg, ',', arg2)
    print (inner.__code__.co_freevars)
    print (inner.__closure__[0].cell_contents)
    return inner

Which prints the following:

In [169]: outer('outer arg')
('arg',)
outer arg

So as you can see the value of arg is preserved even after the function has gone out of scope, since it is a free variable. The binding for arg is kept in the __closure__ attribute.

This is only a hint for further reading, I am by no means an expert.