装饰器是程序开发中经常会用到的一个功能，功能就是在运行原来功能基础上，加上一些其它功能，比如权限的验证，比如日志的记录等等。不修改原来的代码，进行功能的扩展。
比如java中的动态代理，python的注解装饰器。
其实python的装饰器，是修改了代码。
装饰器的工作原理：
def outer(fn):
print('...outer...')
def inner():
print('...inner...')
fn()
return inner
def test():
print('...test...')
test = outer(test)
print('*'*15)
test()
结果如下：
装饰器原理结果.jpg
装饰器就是引用了闭包的概念。装饰器的工作原理如下：
装饰器原理.jpg
现在采用装饰器：
def outer(fn):
print('...outer...')
def inner():
print('...inner...')
fn()
return inner
@outer #就相当于 test = outer(test)
def test():
print('...test...')
test()
输出结果如下：
装饰器结果.jpg
多个装饰器：
def f1(fn):
def f1_inner():
return '<b>'+fn()+'</b>'
return f1_inner
def f2(fn):
def f2_inner():
return '<i>'+fn()+'</i>'
return f2_inner
@f1
@f2
def fun():
return 'hello world!'
print(fun())
结果如下：
多个装饰器结果.jpg
装饰器主要的功能有：
引入日志
函数执行时间统计
执行函数前预备处理
执行函数后清理处理
权限检验等场景
缓存
之前演示的装饰器都是无参调用的，装饰器的传参是如何实现的：
def f1(fn):
def f2(a,b):
print(a,b)
fn(a,b)
return f2
@f1
def fun(a, b):
print(a+b)
fun(10, 20)
输出结果如下：
装饰器传参结果.jpg
这样把参数写死显然不适合装饰器的普遍性，如果有不同参数的函数调用该装饰器，如何改写装饰器：
from time import ctime, sleep
def f1(fn):
def f2(*args, **kwargs):
print('%s call at %s'%(fn.__name__, ctime()))
print(*args, **kwargs)
fn(*args, **kwargs)
return f2
@f1
def fun1(a, b):
print(a+b)
@f1
def fun2(a, b, c):
print(a+b+c)
fun1(10, 20)
sleep(2)
fun2(30, 40, 50)
结果如下：
不定长传参结果.jpg
以上举得被装饰器装饰过的函数都是直接打印，如果是想返回的值的函数使用该装饰器，那装饰器又不具备普遍性，修改装饰器如下：
from time import ctime, sleep
def f1(fn):
def f2(*args, **kwargs):
print('%s call at %s'%(fn.__name__, ctime()))
return fn(*args, **kwargs)
return f2
@f1
def fun1(a, b):
print(a+b)
@f1
def fun2(a, b, c):
return a+b+c
fun1(10, 20)
sleep(2)
print(fun2(30, 40, 50))
结果如下：
return装饰器结果.jpg
如果闭包中的f2没有return fn(args,kwargs)而是直接fn(args,**kwargs)，最后打印得到的结果是None。
装饰器带参数，在原有装饰器的基础上，设置外部变量。
from time import ctime, sleep
def timefun_arg(pre="hello"):
def timefun(func):
def wrappedfunc():
print("%s called at %s %s"%(func.__name__, ctime(), pre))
return func()
return wrappedfunc
return timefun
@timefun_arg("wangcai")
def foo():
print("I am foo")
@timefun_arg("python")
def too():
print("I am too")
@timefun_arg()
def coo():
print("I am coo")
foo()
sleep(2)
too()
sleep(2)
coo()
输出结果如下：
带参数的装饰器.jpg
装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 call() 方法，那么这个对象就是callable的。
类装饰器：
class Dog():
def __init__(self, fun):
self.__fun = fun
def __call__(self, *args, **kwargs):
print('...call...')
return self.__fun(*args, **kwargs)
@Dog #foo = Dog(foo)
def foo():
print('...foo...')
@Dog
def foo1(a, b):
print('...foo1...')
return a+b
foo()
print(foo1(1,2))
结果如下：
类装饰器结果.jpg
当用Dog来装作装饰器对foo函数进行装饰的时候，首先会创建Dog的实例对象
并且会把foo这个函数名当做参数传递到init方法中，即在init方法中的fun变量指向了foo函数体，foo函数相当于指向了用Dog创建出来的实例对象。当在使用foo()进行调用时，就相当于让这个对象()，因此会调用这个对象的call方法。为了能够在call方法中调用原来foo指向的函数体，所以在init方法中就需要一个实例属性来保存这个函数体的引用，所以才有了self.__fun = fun这句代码，从而在调用call方法中能够调用到foo之前的函数体。
