非本地 function 如何在 Python 中存储值

Question

I'm confused about how the get() function works. How can it read the previous values? Are the values are stored in f function? How?

def nonlocalist():
    get = lambda x:'Index out of range!'
    def prepend(value):
        nonlocal get
        f = get
        def get(i):
            if i == 0:
                return value
            return f(i - 1)
    return prepend, lambda x: get(x)

prepend, get = nonlocalist()
prepend(2)
prepend(3)
prepend(4)

get(2)

Answer 1

The values are stored in function objects. Each call to prepend creates a new get function object that refers to the preceding get function object, which still exists, and each get function object that prepend creates stores the value parameter passed to prepend .

When nonlocalist is called, get refers to the lambda function that returns the 'Index out of range.' message. Let's call this get0 . (This term is defined just for this discussion. It doesn't mean anything in the code itself.)

Then when prepend is called after that, it sets f to refer to get0 . Then it redefines get and the new get function object has the value passed to prepend bound into it. We'll call this new get function get1 . Now if get1 is called with a parameter of zero, it will return the value passed to prepend . If it gets called with any other parameter, it will call f , which refers to get0 , with a parameter of zero, and that function, as we have seen, will return the error message regardless of its parameter.

At this point, the get1 function is around because it was just defined and the get0 function is also still around because get1 holds a reference to it as f .

The next call to prepend generates a new function object get2 , which stores that prepend call's value and calls get1 (as f ). When it calls f , it subtracts 1 from the subscript argument i , so i controls how far the f calls travel down the list.

So each call to prepend generates a new and different get n function object that contains a value from prepend and a reference to the preceding get (n - 1) function, all the way back to get0 .

In conclusion, I must say: that is one gnarly nest of functions.