# Tutorials for using functions as return values and implementing closures in Python

Source: Internet
Author: User
function as return value

Higher-order functions can also return a function as a result value, in addition to the ability to accept functions as parameters.

Let's implement the summation of a mutable parameter. In general, the function of summing is defined like this:

`def calc_sum (*args):  ax = 0 for  n in args: Ax    = ax + n  return ax`

But what if you don't need to sum it right away, but in the later code, and then calculate it as needed? You can return the SUM function without returning the result of the summation!

`def lazy_sum (*args):  def sum ():    ax = 0 for    n in args:      ax = ax + n    return ax  return sum`

When we call Lazy_sum (), we return the SUM function instead of summing the result:

```>>> f = lazy_sum (1, 3, 5, 7, 9) >>> F

```

The result of summing is actually computed when the function f is called:

`>>> F () 25`

In this example, we define the function sum in the function lazy_sum, and the inner function sum can refer to the arguments and local variables of the external function lazy_sum, and when Lazy_sum returns the function sum, the relevant parameters and variables are stored in the returned function, which is called " The program structure of the closure (Closure) has great power.

Note again that when we call Lazy_sum (), each call returns a new function, even if the same parameter is passed in:

`>>> f1 = lazy_sum (1, 3, 5, 7, 9) >>> F2 = lazy_sum (1, 3, 5, 7, 9) >>> F1==f2false`

The invocation results of F1 () and F2 () do not affect each other.
Closed Package

Notice that the returned function references the local variable args within its definition, so when a function returns a function, its internal local variables are referenced by the new function, so it is not easy to implement them with a simple closure.

Another problem to be aware of is that the returned function is not executed immediately, but not until F () is called. Let's look at an example:

`def count ():  fs = [] for  I in range (1, 4):    def f ():       return i*i    fs.append (f)  return FSF1, F2, F3 = Count ()`

In the example above, each loop creates a new function and then returns the 3 functions that were created.

You might think that calling F1 (), F2 (), and F3 () results should be 1,4,9, but the actual result is:

`>>> F1 () 9>>> F2 () 9>>> F3 () 9`

All of them are 9! The reason is that the returned function refers to the variable I, but it is not executed immediately. When all 3 functions return, they refer to the variable i has become 3, so the final result is 9.

One thing to keep in mind when returning closures is that the return function does not refer to any loop variables, or to subsequent variables that change.

What if you must refer to a loop variable? The method is to create a function that binds the current value of the loop variable with the parameter of the function, regardless of how the loop variable is subsequently changed, and the value that is bound to the function parameter remains the same:

`>>> def count (): ...   FS = [] ...   For I in range (1, 4): ...     def f (j): ...       def g (): ...         Return j*j       ... Return g     ... Fs.append (f (i))   ... Return FS ... >>> F1, f2, F3 = count () >>> F1 () 1>>> F2 () 4>>> F3 () 9`

The disadvantage is that the code is long and can be shortened with a lambda function.

• Related Keywords:

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

## A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

• #### Sales Support

1 on 1 presale consultation

• #### After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

• Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.