python装饰器的本质，就是闭包！

我们一般谈Python的闭包，都是指普通的入参，而谈装饰器的时候，入参一定有函数！闭包和装饰器，返回的都是函数。函数是代码的最小封装单位，装饰器作用于函数，它不影响函数自身的执行，只是在函数的执行前后增加一些“装饰性”的动作。装饰器被称为python的语法糖(syntax sugar)，也被视为python支持AOP编程(面向切面编程)的工具。

简单装饰器

以下代码实现了一个最简单的额装饰器，功能是给带上装饰器的函数，在函数执行前，增加一行print打印，代码如下：

test1函数加上了calling_trace装饰器，在第7行，这一行代码的作用，相同于第11行的注释。test1还是test1，这个名字没有变，只是换成了一个闭包函数的返回值，此闭包函数，就是装饰器，它接收一个函数作为参数。以上代码运行效果如下：

$ python3 deco.py

calling test1

test1 is runing...

我们还可以稍微复杂一点点，既然是装饰器，被装饰的函数执行前后都可以加点小动作。修改后的代码如下：

def calling_trace(func):

def wrapper():

print('calling', func.__name__)

a = func()

print('this is the reture:',a)

return wrapper

@calling_trace

def test2():

print('test2 is runing...')

return 'www.pynote.net'

# test2 = calling_trace(test2)

test2()

新的装饰器没有改名字，只是获取了被装饰函数的返回值，并将返回值打印出来。运行效果如下：

$ python3 deco.py

calling test2

test2 is runing...

this is the reture: www.pynote.net

test2函数执行前后，都增加了一些动作，作为装饰！

这就是装饰器的概念：不修改已有函数的代码，也不修改已有函数的调用处代码，却达到了丰富函数功能的效果！本质上装饰器是对函数的一种封装，只是我们要理解@语法。

闭包和装饰器

装饰器的本质就是闭包，我们如果把上面这段代码重写一遍，采用闭包的语法形式，不使用@语法，效果是完全一样的：

def calling_trace(func):

def wrapper():

print('calling', func.__name__)

a = func()

print('this is the reture:',a)

return wrapper

def test2():

print('test2 is runing...')

return 'www.pynote.net'

t = calling_trace(test2)

t()

以上代码，没有@语法的使用啦，用变量t来获取calling_trace返回的函数对象，然后调用，效果与使用装饰器完全一样：

$ python3 deco.py

calling test2

test2 is runing...

this is the reture: www.pynote.net

使用@语法，阅读代码就如吃糖！

装饰带参数的函数

如果被装饰的函数有参数，需要在装饰器内部原样复制函数的参数定义。请看示例：

def calling_trace(func):

def wrapper(a,b,c=3):

print('calling', func.__name__)

a = func(a,b,c)

print('reture value:',a)

return wrapper

@calling_trace

def test3(a,b,c=3):

print('test3 is runing...')

return a+b+c

test3(1,2,5)

test3(1,2)

装饰器返回的函数的参数定义，要与被装饰函数的参数定义保持一致！以上代码运行结果如下：

$ python3 deco.py

calling test3

test3 is runing...

reture value: 8

calling test3

test3 is runing...

reture value: 6

就算装饰参数个数不定的函数，语法上也是一样的，请看下面代码，test4函数的参数个数不定：

def calling_trace(func):

def wrapper(*args):

print('calling', func.__name__)

a = func(*args)

print('reture value:',a)

return wrapper

@calling_trace

def test4(*args):

print('test4 is runing...')

return sum(args)

test4(1,2,3,4,5,6,7,8)

test4(23,34,45,56)

*args表示一个tuple，在函数定义处出现，就是packing打包调用时的参数，在调用时出现，就是unpacking展开tuple。跟**kw(对应dict)用法一样。以上代码运行效果：

$ python3 deco.py

calling test4

test4 is runing...

reture value: 36

calling test4

test4 is runing...

reture value: 158

给带参数的函数加装饰器，还有一种更通用更常见的参数写法，这种写法在修改函数参数和调用处时，有可以反过来保持装饰器部分代码不变。示例如下：

def calling_trace(func):

def wrapper(*args, **kw):

print('calling', func.__name__)

a = func(*args, **kw)

print('reture value:',a)

return wrapper

@calling_trace

def test5(a,b,c=3):

print('test5 is runing...')

return a+b+c

test5(1,2)

test5(1,2,c=8)

装饰器中使用*args和**kw来接收和传递参数！这个地方要好好体会，这是python的一个特别精妙的地方。以上代码运行结果如下：

$ python3 deco.py

calling test5

test5 is runing...

reture value: 6

calling test5

test5 is runing...

reture value: 11

带参数的装饰器

本文以上示例，都是不带参数的装饰器，在使用@语法的时候，没有参数。而装饰器本身也可以带参数，通过在装饰器外再使用闭包，给装饰器封装其执行环境，可以使装饰器的功能更强大更灵活，也可以更好的控制函数的执行(比如在某些情况下不执行)。而带参数的装饰器，在语法上，也就跟闭包区分开来。(应该就是这个原因，闭包和装饰器在python中是分成了两个概念)

def calling_trace(run):

def deco(func):

def wrapper(*args, **kw):

print('calling', func.__name__)

if run == 1:

a = func(*args, **kw)

print('reture value:',a)

else:

print('not allow to run')

return wrapper

return deco

# test5 = calling_trace(run=1)(test5)

@calling_trace(run=1)

def test5(a,b,c=3):

print('test5 is runing...')

return a+b+c

@calling_trace(run=0)

def test6(*args):

print('test6 is runing...')

return sum(args)

test5(1,2)

test5(1,2,c=8)

test6(23,34,45,56)

先看一下这段代码的运行结果：

$ python3 deco.py

calling test5

test5 is runing...

reture value: 6

calling test5

test5 is runing...

reture value: 11

calling test6

not allow to run

达到预期，test5可以执行，而test6不允许执行。

calling_trace实际上就是一个闭包，它有一个参数，run，调用calling_trace(run=1)后，就相当于返回了一个有run这个参数的装饰器。然后再用这个装饰器去“修饰”它自己的参数func。这个效果，就如注释掉的那行代码。如果不使用@语法，把那行代码注释打开(放在test5的定义后面)，运行效果一模一样！

多重装饰器

函数可以有多个装饰器！多个装饰器的效果，就相当于对函数进行了多层的封装包裹，而不同的装饰器对函数执行的功能影响，完全独立。比如有个装饰器用来控制函数是否能够被执行，另一个装饰器控制函数的所有raise出来的异常。

@a

@b

@c

def tt(): pass

# tt = a(b(c(tt)))

tt函数上面带3个装饰器，想过正如注释掉的那行代码。

我真的觉得python装饰器的设计，实在是非常精妙！

-- EOF --