python 闭包和装饰器

python 闭包和装饰器

一、闭包
闭包：外部函数FunOut()里面包含一个内部函数FunIn(),并且外部函数返回内部函数的对象FunIn，内部函数存在对外部函数的变量的引用。那么这个内部函数FunIn就叫做闭包。你在调用函数FunA的时候传递的参数就是自由变量

# 实例1

def FunOut(name): #外部函数包含内部函数
def FunIn(age):
print ("name:",name,"age:",age) # 内部函数存在对外部函数变量的引用，如name
return FunIn # 返回内部函数对象FunIn
FunIn = FunOut("Alian") # Alian传给参数name,并且返回函数FunIn对象给Funin
FunIn(25) # 此时Funin相当于调用函数FunIn，因此25传给参数age
# ('name:', 'Alian', 'age:', 25)

解析：里面调用FunOut()的时候就产生了一个闭包FunIn，并且该闭包持有自由变量name，因此这也意味着，当函数FunOut()的生命周期结束之后，自由变量name依然存在，因为它被闭包引用了，所以不会被回收。

#实例2

def line_conf(a,b):
def line(x):
return a * x + b
return line

line1 = line_conf(1,1)
line2 = line_conf(4,5)
print (line1(5),line2(5))
# (6, 25)

解析：函数line与环境变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数

闭包作用：闭包也具有提高代码可复用性的作用

二、装饰器
装饰器概念： 装饰器本质上也是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器接受其他函数为参数并返回一个装饰过的函数（或其他对象）。

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。

def now():
print ("2017-05-31")

f = now
f()
# 2017-05-31

函数对象有一个__name__属性，可以拿到函数的名字：

now.__name__
# 'now'
f.__name__
# 'now'

　　

假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：

def log(func):
def wrapper(*args,**kw):
print ("call %s():"%func.__name__)
return func(*args,**kw)
return wrapper

观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：

@log
def now():
print ("2017-05-31")

　　

调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：

now()
# call now():
# 2017-05-31

　　

把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

　　

由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：

def log(text):
def decorator(func):
def wrapper(*args,**kw):
print ('%s %s():' % (text, func.__name__))
return func(*args,**kw)
return wrapper
return decorator

这个3层嵌套的decorator用法如下：

@log("execute")
def now():
print ("2017-05-31")

　　

执行结果：

now()
# execute now():
# 2017-05-31

解析：首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数

和两层嵌套的decorator相比，3层嵌套的效果是这样的：

now = log ("execute")(now)

以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：

因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

import functools
def log(func):
@functools.wraps(func)
def wrapper(*args,**kw):
print ('call %s():' % func.__name__)
return func(*args,**kw)
return wrapper

　　

# 或者针对带参数的decorator：

import functools
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print ('%s %s():' % (text, func.__name__))
return func(*args,**kw)
return wrapper
return decorator

　

参考：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000