函数定义中为什么可返回函数内部定义的函数？

引至知乎 python里为什么函数可以返回一个函数内部定义的函数？—-陈伟

1.Python中一切皆对象

2.函数是第一类对象

3.函数对象VS函数调用

4.闭包&LEGB法则

所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象
举个例子，在foo.py模块中定义：

# foo.py
filename = "foo.py"

def call_func(f):
    return f()    # f引用一个函数对象，然后调用它

在另一个func.py模块中，写下如下代码：

# func.py
import foo
filename = "func.py"
def show_filename():
    return "filename: %s" % filename
if __name__ == "__main__":
    print foo.call_func(show_filename) # 实际发生调用的位置，是在foo.call_func函数中

当我们用python func.py命令执行时，输出为：
filename: func.py

对于嵌套函数，这一机制会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：

# enclosed.py
import foo
def wrapper():
    filename = "enclosed.py"
    def show_filename():
        return "filename: %s" % filename
    print foo.call_func(show_filename) # 输出:filename:enclosed.py

实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的globals属性：

#show_filename inside wrapper
#show_filename.__globals__
{
'__builtins__': <module '__builtin__' (built-in)>,
#内建作用域环境
'__file__': 'enclosed.py',

'wrapper': <function wrapper at 0x7f84768b6578>,
#直接外围环境
'__package__': None,
'__name__': '__main__',

'foo': <module 'foo' from '/home/chiyu/foo.pyc'>,
#全局环境
'__doc__': None

}

当代码执行到show_filename中的return “filenam: %s” % filename语句时，解析器按照如下顺序查找filename变量：
I Local-本地函数(show_filename)内部，通过任何方式赋值的，并且没有被global关键字声明为全局变量的filename变量；
II Enclosing-直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)；
III Global-全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；
IIII Builtin-内置模块(builtin)中预定义的变量名中查找filename变量；

在任何一层先找到了符合要求的filename变量，则不再向更外层查找。如果直到Builtin层仍没有找到符合要求的变量，则抛出NameError异常。这就是变量名解析的：LEGB法则。

总结
1.闭包最重要的使用价值在于：封存函数执行的上下文环境；
2.闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常。

5.装饰器&语法糖(syntax sugar)

闭包和装饰器有什么关系？

上文提到闭包的重要作用：封存上下文，这一特性可以巧妙地被用于现有函数的包装，从而为现有函数增加功能。这就是装饰器。

举个栗子：

alist = range(1, 101)
def lazy_sum():
    return reduce(lambda x, y: x + y, alist)

我们定义一个函数lazy_sum，作用是对alist中的所有元素求和后返回。但出于某种原因，我们并不想马上返回结果，而是在之后的某个地方，通过显示的调用输出结果。于是用一个wrapper函数进行包装：

def wrapper():
    alist = range(1, 101)
    def lazy_sum():
        return reduce(lambda x, y: x + y, alist)
    return lazy_sum
lazy_sum = wrapper()
#wrapper()返回的是lazy_sum函数对象

if __name__ == "__main__":
    lazy_sum() #5050        

这是一个典型的Lazy Evaluation的例子。我们知道，在一般情况下，局部变量在函数返回时，就会被垃圾回收器回收，而不能再被使用。但是这个alist并没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法并不准确，实际上是包含在了lazy_sum的执行环境中，通过globals），从而延长了生命周期。

当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050。

当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：

def add(a, b):
    return a + b

这个函数计算a + b的和并返回，但我们知道Python是动态类型+强类型的语言，你并不能保证用户传入的参数a和b一定是两个整形，他有可能传入了一个整数和一个字符串类型的值。

动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候：
强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不可能将它当作一个字符串（例如直接尝试将一个整形和一个字符串做+运算）；

因此，为了更加优雅的使用add函数，我们需要在执行+运算前，对a和b进行参数检查。这时候装饰器就显得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):
    return a + b

def checkParams(fn):
    def wrapper(a, b):
        if isinstance(a, (int, float)) and isinstance(b, (int, float)):    #检查参数a和b是否都为整形或浮点型
            return fn(a, b)   #是则调用fn(a, b)返回计算结果
        logging.warning("variable 'a' and 'b' cannot be added")    #否则通过logging记录错误信息，并友好退出
        return 
    return wrapper #fn引用add，被封存在闭包的执行环境中返回

if __name__ == '__main__':
    #将add函数对象传入，fn指向add
    #等号左侧的add，指向checkParams的返回值wrapper
    add = checkParams(add)

    add(3, 'hello')    #经过类型检查，不会计算结果，而是记录日志并退出

注意checkParams函数：
- 首先看参数fn，当我们调用checkParams(add)的时候，它将成为函数对象add的一个本地（Local）引用；
- 在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用fn(a, b)，根据LEGB法则，最终解释器将搜索几个作用域，并最终在（Enclosing层）checkParams函数的本地作用域中找到fn;
- 注意最后的return wrapper, 这将创建一个闭包，fn变量（add函数对象的一个引用）将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收；

当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn，继续调用原始的add进行+运算。
因此调用add(3, ‘hello’)将不会返回计算结果，而是打印出日志：

WARNING: root:variable 'a' and 'b' cannot be added

有人觉得add = checkParams(add)的写法太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：

@checkParams
def add(a, b):
    return a + b

这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行。