Python返回函数、闭包，匿名函数

函数作为返回值
高阶函数除了可以接收函数作为参数外，还可以把函数作为结果值返回。

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

f = lazy_sum(1,2,3,4,5)
print f
# <function sum at 0x02657770>
# lazy_sum(1,2,3,4,5)返回的是一个指向求和的函数的函数名。
# 在调用lazy_sum(1,2,3,4,5)的时候，不立刻求和，而是根据后面代码的需要在计算。
print f()
# 15
# 用f()调用求和函数，计算出结果。

f1 = lazy_sum(1,2,3,4,5,6)
f2 = lazy_sum(1,2,3,4,5,6)
print f1 == f2
# False
# lazy_sum()每调用一次，都会返回一个独一无二的函数地址。    

例中，lazy_sum中的内部函数sum引用了外部函数lazy_sum的参数和局部变量，
当lazy_sum返回函数sum时，相关参数和变量已经保存在返回的函数sum中了。
我们称这为 闭包。

 

若要返回一个列表，列表每个元素都是函数。要注意闭包中局部变量的使用

def count():
　　fs = []
　　for i in range(1,4):
　　　　def f():
　　　　　　return i*i
　　　　fs.append(f)
　　return fs

f1, f2, f3 = count()
print f1()
print f2()
print f3()
# 9
# 9
# 9

结果全部都是9. 不是预期的1,4,9。
原因是返回函数引用了变量i，下面来解析一下f1,f2,f3=count()这句的执行过程：
　　 当i=1, 执行for循环， 结果返回函数f的函数地址，存在列表fs中的第一个位置上。
　　 当i=2, 由于fs列表中第一个元素所指的函数中的i是count函数的局部变量，i也指向了2；然后执行for循环， 结果返回函数f的函数地址，存在列表fs中的第二个位置上。
　　 当i=3, 同理，在fs列表第一个和第二个元素所指的函数中的i变量指向了3； 然后执行for循环， 结果返回函数f的函数地址，存在列表fs中的第三个位置上。
所以在调用f1()的时候,函数中的i是指向3的：
  f1():
     return 3*3
同理f2(), f3()结果都为9

 

闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。即包在里面的函数（本例为f()），不要引用外部函数(本例为count())的任何循环变量

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

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()
print f1()
print f2()
print f3()

结果就是预期的1,4,9.
当i=1时，f(1)即让j指向1，
当i=2时，f(2)即让j指向2，此时j不是count的局部变量，不会影响到i=1是f(1)中j的指向。即函数f的参数绑定循环变量当前的值, 而不是循环变量本身。

 

 

匿名函数

print map(lambda x: x*x, [1,2,3,4,5,6])
#[1, 4, 9, 16, 25, 36]

匿名函数，没有函数名，不必担心函数名冲突。
匿名函数有一个限制,就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

 

匿名函数也是一个函数对象，也可以把匿名函数。

f = lambda x: x*x
print f
print f(5)
# <function <lambda> at 0x025277F0>
# 25

 

同样，也可以把匿名函数同为返回值返回。

def build(x,y):
    return lambda: x*x +y*y
f = build(1,5)
print f
print f()
# <function <lambda> at 0x025377F0>
# 26