Shulou(Shulou.com)06/01 Report--

This article introduces the relevant knowledge of "how to implement Python closures". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. The concept of closure

Please understand with me that if another function is defined on the inside of a function, we call it an outer function on the outside and an inner function on the inside. Closure: an inner function is defined in an outer function, the temporary variable of the outer function is used in the inner function, and the return value of the outer function is a reference to the inner function. This constitutes a closure. In general, in our understanding, if a function ends, everything inside the function will be released and returned to memory, and the local variables will disappear. But the closure is a special case. If the outer function finds that it has its own temporary variable that will be used in the internal function in the future, it will bind the temporary variable to the internal function and then end it itself.

2. Implement a closure # return the function as a return value, which is also a high-order function # which is also called a closure Through the closure, you can create some variables that can only be accessed by the current function # you can hide some private data in the closure def outer (): a = 10 # function def inner (): print ('I am outer', a) # returns the internal function inner as a return value return inner# r is a function object Is the function object returned after calling fn () # this function is actually defined internally by fn () It is not a global function # so this function can always access variables within the fn () function # the outer function returns a reference to the inner function fn = outer () # r () is equivalent to calling the inner () function print ("outer reference address:", outer) print ("inner reference address:", fn) fn () "" output: outer reference address: inner reference address: I am outer 10 ""

Describe the above code:

For the closure, the last return inner in the outer function outer, when we call the outer function fn = outer (), the outer function returns the inner function object, which is a reference to a function that is stored in the fn object. So the next time we do fn (), we run the inner function.

Tip:

A function, if the function name is followed by a pair of parentheses, is equivalent to calling the function. If it is not followed by parentheses, it is equivalent to just the name of a function, which contains a reference to the location of the function.

3. Bind the temporary variable to the inner function in the closure

According to our normal understanding, when a function ends, it releases its temporary variables back to memory, and then the variables no longer exist. In general, this is indeed the case. But closures are a special case. The external function finds that its own temporary variable will be used in the internal function in the future. When it ends, when it returns the inner function, it will send the temporary variable of the outer function to the inner function to bind together. So the outer function is over, and the temporary variables of the outer function can still be used when calling the inner function.

In the example I wrote, I called the external function outer twice, passing values of 10 and 20, respectively. The inner function is defined only once, and we find that when the inner function is called, the temporary variable that can recognize the outer function is different.

Everything in Python is an object, although we only define the function once, but when the outer function is running, it actually executes according to the inner code. Every time we call the outer function, it creates an inner function. Although the code is the same, it creates a different object, and binds the temporary variable value to the inner function each time, and then returns the inner function reference.

So every time we call an external function, we return references to different instance objects, and their functions are the same, but they are not actually the same function object.

The following example demonstrates:

Def outer (num): a = num # function def inner (): print ('I am outer', a) # returns the inner function inner as the return value return innerfn1 = outer (10) fn2 = outer (20) print ("inner reference address:", fn1) fn1 () print ("inner reference address:" Fn2) fn2 () "" output result: inner reference address: I am outer 10inner reference address: I am outer 20 "" # Note the addresses of the two inner are not the same One is 8B8, the other is 828. 4. the inner function in the closure modifies the local variable of the outer function.

In basic Python syntax, a function can read global data at will, but there are two ways to modify global data

Global declares global variables. It can be modified when the global variable is variable type data.

The same is true of functions in closures. When you want to modify the closure variable in the inner function (the outer function is bound to the local variable of the inner function), in Python3, you can declare a variable with the nonlocal keyword, indicating that the variable is not a variable in the local variable space, and you need to look for this variable in the upper variable space.

Example:

Def outer (num): a = num b = 10 # an and b are closure variables print ("original a value is", a) # inner function def inner (): function in # want to modify closure variable # nonlocal keyword declare variable nonlocal an a + = b print ('I am an of outer' A) # return the inner function inner as the return value return innerfn1 = outer (10) fn1 () "output the result: the original a value is 10 and I am a 20" of outer.

In the inner function, the closure variable is modified, and the printed result is indeed the result of the modification.

5. Note:

It is also important to note that there is actually only one closure variable, one at a time. (this explains more under the simple interest mode implemented by Python)

Def outer (num): a = num b = 10 # an and b are closure variables print ("original a value is", a) # inner function def inner (): function in # want to modify closure variable # nonlocal keyword declare variable nonlocal an a + = b print ('I am an of outer' A) # return the inner function inner as the return value return innerfn1 = outer (10) fn1 () "" output result: the original a value is 10 I am a 20 of outer I am a 30 of outer I am a 40 "of outer

You can see that the second call to the fn1 () method increases the value of a by 10.

6 、 Exercise: # find the average of multiple numbers # nums = [50 sum 30 / 10] # sum () is a summation function # sum () is used to find the sum of all elements in a list # print (sum (nums) / len (nums)) # result: 37.elements for forming closures # nesting of ① functions # ② returns internal functions as return values # ③ internal functions must be used outside The variable def make_averager () of the partial function: # create a list To save the numeric value nums = [] # create a function to calculate the average def averager (n): # add n to the list nums.append (n) # find the average return sum (nums) / len (nums) return averager# create an object Now you have obtained the reference to the inner function object averager = make_averager () # call the connotation book object # Note here, although it is the object created by calling the outer function, # but the reference to the inner function object is obtained, and the inner function is a tangible parameter, so the averager object is equivalent to the inner function object. # so when calling the inner function, you have to pass the parameter. Print (averager (10)) print (averager (20)) print (averager (30)) print (averager (40)) "how to implement Python closure" is introduced here, thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.