Python-装饰器

一、什么是装饰器

装饰器就是用来为被修饰对象添加上新功能的工具

注意：装饰器本身可以是任意可调用对象，被装饰器的对象也可以是任意可调用对象

那为什么要用装饰器呢？

这里我们需要知道开放封闭原则：封闭指的是对修改封闭，对扩展开放

装饰器的实现必须遵循两大原则：

　　1.不修改被装饰对象的源代码

　　2.不修改被装饰对象的调用方式

装饰的目标：就是在满足1和2的前提下为被修饰对象添加上新功能

简单的装饰器：

import time
def index():
    print('welcome to index page')
    time.sleep(3)

def outter(func): # func=最原始那个index的内存地址
    def wrapper():
        start=time.time()
        func() #最原始的那个index的内存地址()
        stop=time.time()
        print('run time is %s' %(stop - start))
    return wrapper

index=outter(index) #index=outter(最原始那个index的内存地址) #index=wrapper的内存地址
index() #wrapper的内存地址()      

上面这种装饰器没有传入参数，下面对他进行升级

def home(name):
    print('welcome %s to home page' %name)
    time.sleep(2)
    return 123

def timmer(func): #func=最原始那个home函数的内地址
    def wrapper(*args,**kwargs): #args=('egon',) kwargs={}
        start=time.time()
        res=func(*args,**kwargs) #最原始那个home函数的内地址('egon')
        stop=time.time()
        print('run time is %s' %(stop - start))
        return res
    return wrapper

home=timmer(home) #home=outter(最原始那个home函数的内地址) #home=wrapper函数的内地址
res=home('egon') # res=wrapper函数的内地址('egon')      

参数是可以传入了，那还有没有可以优化的地方呢，这个时候就用到了python的语法糖，

def outter(func):
    def wrapper(*args,**kwargs):
        #在调用函数前加功能
        res=func(*args,**kwargs) #调用被装饰的\也就是最原始的那个函数
        #在调用函数后加功能
        return res
    return wrapper

@outter #index=outter(index) #index=wrapper
def index():
    print('welcome to index page')
    time.sleep(3)

index()      

装饰器的语法糖：在被装饰对象正上方单独一行写@装饰器的名字

运行原理：python解释器一旦运行到@装饰器的名字，就会调用装饰器，然后将被装饰函数的内存地址当做参数传给装饰器，最后将装饰器调用的结果赋值给原函数名

调用多个装饰器：

def outter1(func1): #func1=wrapper2
    print('outter1')
    def wrapper1(*args,**kwargs):
        print('wrapper1')
        res1=func1(*args,**kwargs) #res1=wrapper2(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2): #func2=最原始的那个index的内存地址
    print('outter2')
    def wrapper2(*args,**kwargs):
        print('wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2


@outter1 # index=outter1(wrapper2) #index=wrapper1
@outter2 #outter2(最原始的那个index的内存地址) ===> wrapper2
def index():
    print('welcome to index page')
    time.sleep(3)

index()  #wrapper1()

'''
outter2
outter1
wrapper1
wrapper2

'''      

解释顺序是自下往上的，执行顺序从上往下，那打印的结果和我们预想的不一样呢，我们应该理解装饰器函数在被装饰器函数定义好后立即执行

模板：

# 有参装饰器的模板
def outter1(x,y,z):
    def outter2(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter2

# 无参装饰器的模板
def outter(func):
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        return res
    return wrapper      

补充：

调用方式和源代码都没有修改，是不是所有都很完美了呢？不是其实还有一个需要注释的地方就是注释文档

def outter(func):
    # @wraps(func)
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res

    return inner
@outter
def index():
    '''
    zfj
    1212
    1231

    '''
    # print('1111')
index()
print(index.__name__)# inner
print(index.__doc__)#None      

index的函数名和文档都变成inner的了，没有和原来的index一样，这是我们可以在inner函数中加入

inner.__name__=func.__name__
inner.__doc__= func.__doc__
这样index得到的文档就是原来的样子了，还有一个方法是使用wraps！      

from functools import wraps
def outter(func):
    @wraps(func)
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    # inner.__name__=func.__name__
    # inner.__doc__= func.__doc__
    return inner
@outter
def index():
    '''
    zfj
    1212
    1231

    '''
    # print('1111')
index()
print(index.__name__)
print(index.__doc__)      

很感谢Nisen的装饰器执行顺序迷思，对我的启发很大

https://segmentfault.com/a/1190000007837364

焚膏油以继晷，恒兀兀以穷年。