python三大神器之装饰器

装饰器的形成过程

假如你要写一个计算函数执行时间的函数,代码如下:

 import time

 def func1():
     print('in func1')

 def timer(func):
     def inner():
         start = time.time()
         func()
         print(time.time() - start)
     return inner

 func1 = timer(func1)
 func1()

唯一碍眼的那句话就是还要在做一次赋值调用,你觉得碍眼，python的开发者也觉得碍眼，所以就为我们提供了一句语法来解决这个问题！

 import time
 def timer(func):
     def inner():
         start = time.time()
         func()
         print(time.time() - start)
     return inner

 @timer   #==> func1 = timer(func1)
 def func1():
     print('in func1')

 func1()

到这里，我们可以简单的总结一下：

　　装饰器的本质：一个闭包函数

　　装饰器的功能：在不修改原函数及其调用方式的情况下对原函数功能进行扩展

还有最后一个问题要解决，刚刚我们讨论的装饰器都是装饰不带参数的函数，现在要装饰一个带参数的函数怎么办呢？

 def timer(func):
     def inner(a):
         start = time.time()
         func(a)
         print(time.time() - start)
     return inner

 @timer
 def func1(a):
     print(a)

 func1(1)

 装饰器——带参数的装饰器

其实装饰带参的函数并不是什么难事，但假如你有两个函数，需要传递的参数不一样呢？

 import time
 def timer(func):
     def inner(*args,**kwargs):
         start = time.time()
         re = func(*args,**kwargs)
         print(time.time() - start)
         return re
     return inner

 @timer   #==> func1 = timer(func1)
 def func1(a,b):
     print('in func1')

 @timer   #==> func2 = timer(func2)
 def func2(a):
     print('in func2 and get a:%s'%(a))
     return 'fun2 over'

 func1('aaaaaa','bbbbbb')
 print(func2('aaaaaa'))

现在参数的问题已经完美的解决了，可是如果你的函数是有返回值的呢？

 import time
 def timer(func):
     def inner(*args,**kwargs):
         start = time.time()
         re = func(*args,**kwargs)
         print(time.time() - start)
         return re
     return inner

 @timer   #==> func2 = timer(func2)
 def func2(a):
     print('in func2 and get a:%s'%(a))
     return 'fun2 over'

 func2('aaaaaa')
 print(func2('aaaaaa'))

刚刚那个装饰器已经非常完美了，但是正常我们情况下查看函数的一些信息的方法在此处都会失效

 1 def index():
 2     '''这是一个主页信息'''
 3     print('from index')
 4
 5 print(index.__doc__)    #查看函数注释的方法
 6 print(index.__name__)   #查看函数名的方

为了不让他们失效，我们还要在装饰器上加上一点来完善它：

 from functools import wraps

 def deco(func):
     @wraps(func) #加在最内层函数正上方
     def wrapper(*args,**kwargs):
         return func(*args,**kwargs)
     return wrapper

 @deco
 def index():
     '''哈哈哈哈'''
     print('from index')

 print(index.__doc__)
 print(index.__name__)

开放封闭原则

　　1.对扩展是开放的

　　　　为什么要对扩展开放呢？

　　　　我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

　　2.对修改是封闭的

　　　　为什么要对修改封闭呢？

　　　　就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

装饰器完美的遵循了这个开放封闭原则。

 

装饰器的主要功能：

在不改变函数调用方式的基础上在函数的前、后添加功能。

装饰器的固定格式：

#普通版本
def timer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner
# wraps版本
from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

带参数的装饰器

可以实现函数是否执行

 def outer(flag):
     def timer(func):
         def inner(*args,**kwargs):
             if flag:
                 print('''执行函数之前要做的''')
             re = func(*args,**kwargs)
             if flag:
                 print('''执行函数之后要做的''')
             return re
         return inner
     return timer

 @outer(False)
 def func():
     print(111)

 func()

多个装饰器装饰同一个函数

有些时候，我们也会用到多个装饰器装饰同一个函数的情况。

 def wrapper1(func):
     def inner():
         print('wrapper1 ,before func')
         func()
         print('wrapper1 ,after func')
     return inner

 def wrapper2(func):
     def inner():
         print('wrapper2 ,before func')
         func()
         print('wrapper2 ,after func')
     return inner

 @wrapper2
 @wrapper1
 def f():
     print('in f')

 f()