Detailed introduction to Python closures

In computer science, closure (Closure) is the abbreviation of lexical closure (Lexical Closure), which is a function that references free variables. The referenced free variable will remain with the function even after it has left the environment in which it was created. Therefore, there is another way of saying that a closure is an entity composed of a function and its associated reference environment. Closures can have multiple instances at runtime, and different reference environments and the same function combination can produce different instances.

I prefer the latter, treating closures as a structure for organizing code, for reasons I will explain later.

What is the closure code structure?

In Python, everything is an object, which of course includes functions. Function objects can be assigned to a variable, and the function can be called through this variable; function objects can also be passed as parameters, and can also be used as the return result of a function. Moreover, in Python, functions can be nested.

Python is based on function objects and provides support for the grammatical structure of closures

Let’s look at an example first

def f1():
    name1 = 'Alice'
    name2 = 'Bob'
    def f2():
        print('hello,%s,%s' %(name1,name2))    return f2 


if __name__ == '__main__':
    name1 = 'David'
    name2 = 'Frank'
    func = f1()
    func()
    print(func.__closure__)
    print(func.__closure__[0].cell_contents)
    print(func.__closure__[1].cell_contents)# 输出hello,Alice,Bob
(<cell at 0x03A55CF0: str object at 0x03CBEA20>, <cell at 0x03CBEAD0: str object at 0x03CBEAA0>)
Alice
Bob

Function f2 is defined inside function f1 and is called The variables name1 and name2 defined in f1 are removed.

f1 returns the function object f2, but in fact the returned f2 already includes the variables name1 and name2 in f1. This can be seen from the running results of the code.

In the main program, although name1 and name2 are redefined, the variable value when the function func is executed is still called when it is defined, that is, its reference environment variable, not the variable value when it is used.

To summarize, in Python, a closure is a code block that contains functions and referenced environment variables. I tend to think of closures as a code structure rather than a function, because the first call When it is used, it only wraps the reference environment of the closure and the internal function together, and returns it as a function object, without executing the internal function. When this function object is called, the internal function function will be executed.

The value of the reference environment variable is saved in the closure attribute of the function object. The closure contains a tuple. Each element in this tuple is an object of type cell. We see that the first cell contains Alice, which is the value of the environment variable name1 when we created the closure. This can be seen from the results of the above code.

Now look back and see the encyclopedia’s explanation of closures.

Now, give another example:

# 此例子转自伯乐在线def line_def(a, b):
    def line(x):
        return a * x + b    return lineif __name__ == '__main__':
    func = line_def(2, 3)
    print(func(5))# 输出13

In this example, the function line and the environment variables a, b form a closure. We only need to change the values ​​​​of a, b to obtain Different straight line functions improve encapsulation, so that we only need to pay attention to the parameters a and b, and do not care about the implementation of the internal straight line.

The biggest feature of closure is that it can bind the variables of the external function to the internal function and return the function after binding the variable (that is, the closure). At this time, even if the environment in which the closure is generated (the external function ) has been released, the closure still exists.

One of the major applications of closures is decorators, but they pass functions. I’ll write this next time.

The above is the detailed content of Detailed introduction to Python closures. For more information, please follow other related articles on the PHP Chinese website!