1.python中一切皆对象
首先从概念上看“在python中， 函数本身也是对象”
当执行：
alist = [1, 2, 3]
时，你就创建了一个列表对象，并且用alist这个变量引用它。
也可以自己定义一个类：
class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
[....] #other code
return price
然后创建一个类的对象：
houce = House(200, 'Shanghai')
这个对象有一些属性(area， city)和一些方法(__init__, self):
2.函数是第一类对象
和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：
def func(a, b):
return a+b
在全局域，函数对象被函数名引用着，他接收两个参数a和b，计算这两个参数的和作为返回值
所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当做数据处理，例如赋值、作为参数传递给函数，或者作为返回值return等
因此，可以用其他变量名引用这个函数对象：
add = func
这样就可以像调用func(1, 2)一样，通过新的引用调用函数了：
print func(1, 2)
print add(1, 2)
3
3
也可以将函数对象作为参数，传递给另一个函数：
def caller_func(f):
return f(1, 2)
if __name__ = "__main__":
print caller_func(func)
由此看出：
- 函数对象
func作为参数传递给caller_func函数，传参过程类似于一个赋值操作：f = func - 于是func函数对象，被
caller_func函数作用域中的局部变量f引用，f实际指向了函数func - 当执行
return f(1, 2)的时候，相当于执行了return func(1, 2)
因此结果输出为3
3.函数对象 vs 函数调用
无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用
例如定义了下面这个函数：
def func():
return "hello, world"
然后分别执行两次赋值：
ref1 = func #将函数对象赋值给ref1
ref2 = func() #调用函数， 将函数的返回值赋值给ref2
这两种赋值容易混淆，可以通过type函数来查看一下两次赋值的类型：
type(ref1)
function
type（ref2）
str
可以看到，ref1引用了函数对象本身， 而ref2则引用了函数的返回值，通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：
callable(ref1)
True
callable(ref2)
False
传参的的效果类似
4.闭包&LEGB法则
所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象
假设在foo.py模块中作了如下定义：
#foo.py
filename = "foo.py"
def call_func(f):
return f() # f引用了一个函数对象，然后调用它
在另一个func.py的模块，写下了这样的代码：
#func.py
import foo #导入foo.py
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命令执行func.py时输出结果为：
filename：func.py
可以看出show_filename()函数使用的filename变量的值，是在与它相同环境（func.py）中定义的那个，尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部
而对于嵌套函数，这一机制则会表现得更加明显：闭包将会捕捉内层函数执行所需的整个环境
#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
实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__global__属性：
{
#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 "/mystuff/foo.pyc">
"__doc__": None
}
当代码执行到show_filename中的return"filename: %s" %filename语句时，解析器按照下面顺序查找filename变量：
Local：本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量
Enclosing：直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)
Global：全局空间(模块enclosed.py)，在模块顶层赋值的filename变量
Builtin：内置模块(__builtin__)中预定义的变量名中查找filename变量
在任何一层先找到了符合要求的filename变量，则不再向更外层查找，如果知道Builtin层仍然没有找到符合要求的变量，则抛出NameError异常，这就是变量名解析的：LEGB法则
总结： 闭包最重要的使用价值在于：封存函数执行的上下文环境
闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常
5.装饰器 (syntax sugar)
闭包和装饰器之间的关系：
上文提到闭包的重要特性：封存上下文，这一特性可以巧妙地被用于现有函数的包装，从而为现有函数增加功能，此乃装饰器
举个栗子：
#alist = [1, 2, 3, ..., 100] --> 1+2+3+...+100 = 5050
def lazy_sum():
return reduce(lambda x, y: x+y， alist)
我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回，alist假设是1到100的整数列表
alist = range(1, 101)
但是出于某种原因不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果，于是用一个wrapper函数对其进行包装：
def wrapper():
alist = range(1, 101)
def lazy_sum():
return reduce(lambda x, y: x+y， alist)
return lazy_sum
lazy_sum = wrapper()
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一定是两个整型，他可能传入了一个整型和一个字符串类型的值，这时，解析器就会抛出一个TypeError异常.
动态类型：在运行期间确定变量的类型，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)):
return fn(a, b)
# 如果参数类型不正确，则同通过logging记录错误信息并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
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的一个本地(L)引用
在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用了fn(a, b)，根据LEGB法则，解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn
注意最后的return wrapper，这将创建一个闭包， fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收
当调用add(3, “Hello”)将不会返回计算结果，而是打印出日志
有人觉得add = checkParams(add) 这样的写法太过麻烦，于是python提供了一种更优雅的写法，称之为 语法糖：
@checkParams
def add(a, b):
return a + b
这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行
6.回归问题
def addspam(fn):
def new(*args):
print "spam, spam, spam"
return fn(*args)
return new
@addspam
def useful(a, b):
print a**2 + b**2
首先看第二段代码：
@addspam装饰器，相当于执行了useful = addspam(useful)，这里有个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果
再回到addspam函数体：
return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收
而fn此时是useful的一个引用，当执行return fn(*args)时，实际相当于执行了return useful(*args)
附代码执行过程中的引用关系图：
