关于函数式编程思考

闭包——嵌套在内部的函数声明，同时声明的函数作为返回值
高级函数——filter，map和reduce，函数的参数迭代操作
lambda——匿名函数
callback——在函数作为唯一参数，内部调用其他函数，调用后返回当前函数体
函数式编程，函数作为普通变量，可做参数，可返回，可嵌套，可匿名，可迭代
闭包可以被理解为一个只读的对象，你可以给他传递一个属性，但它只能提供给你一个执行的接口
闭包和类有点相似，相似点在于他们都提供了对数据的封装，不同的是闭包本身就是个方法。

闭包结构特征

嵌套结构
内部函数用到外部函数变量
外部函数返回值为内部函数

例子

def pow_x(x):
    def echo(value):
        return value**x
    return echo

lst = [pow_x(2), pow_x(3), pow_x(4)]
for p in lst:
    print p
    print p(3)  // pow_x(2)(3), pow_x(3)(3), pow_x(4)(3)

内部函数改变外部函数变量，思考闭包函数的变量作用域

# coding: utf-8

def pow_y(x):
    def echo(value):
##        x[0] = x[0]*2  //在内部函数将外部的x某一个值进行修改，并没有变更x的引用
##        x = [2, 3]  //这里将外部函数的x变成了局部变量
        return value**x[0], value**x[1]

    return echo

lst2 = pow_y([1, 1])
print lst2(2)
print lst2(3)
print lst2(4)

从外部修改变量的值，对比上一个例子体会下差别

def larger(x):
    def echo(value):
        print "value:",value, "x:", x, "x[0]:", x[0], "type(x)", type(x)
        return True if value > x[0] else False
    return echo

x=[10]
larger10 = larger(x)
print x[0], larger10(2)

x[0] = 1
print x[0], larger10(2)

x = 100  ## 此处的x并不会变更闭环环境中的x，闭包中的x并没有被回收
##  larger10 = larger(x) 重新生成闭包环境，所以会报错
print type(x), larger10(2)

闭包只是在形式和表现上像函数，但实际上不是函数。函数是一些可执行的代码，这些代码在函数被定义后就确定了，不会在执行时发生变化，所以一个函数只有一个实例。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

外部函数的局部变量可以被内部函数引用，即使外部函数已经返回了。

def generate_power_func(n):
    print "id(n): %X" % id(n)
    def nth_power(x):
        return x**n
    print "id(nth_power): %X" % id(nth_power)
    return nth_power

print generate_power_func(4)
print generate_power_func(4)(2)  #闭包实例中包含的变量不会被回收

参考文献：
1.浅显理解 Python 闭包
2.闭包的概念、形式与应用
3.Python 的闭包和装饰器
4.python中的闭包
5.Python中的闭包