PYTHON装饰器

python装饰器本质上是一个python函数，他可以让其他函数在不需要做任何代码变动的前提下增加额外功能。也就是说，不修改原函数的代码，也不改变原函数的调用方式，即可添加附加功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。话不多说，先来一段代码看看：

import time
def timmer(func): #func=test
    def wrapper():
        # print(func)
        start_time=time.time()
        func() #就是在运行test()
        stop_time = time.time()
        print('运行时间是%s' %(stop_time-start_time))
    return wrapper
#@timmer  就相当于 test=timmer(test)    
@timmer #test=timmer(test) #返回的是wrapper的地址
def test():
    time.sleep(3)
    print('test函数运行完毕')
test()  执行的是wrapper()

从上边的代码中我们可以看出，@语法糖实现了装饰器的功能，装饰器是一个函数，由高阶函数和函数嵌套生成。那么什么是高阶函数呢？
高阶函数：可以理解为函数的参数是一个函数，或者函数的返回值是一个函数名，二者只要满足一个条件就可以形成一个高阶函数；

 def foo():
      print('你好高师傅!')
 def test(func):
      print(func)
      func()
 test(foo)#test就是一个高阶函数，实参是一个函数

函数嵌套：简单的理解就是函数中再定义函数；
其实一个装饰器其主要有三部分：高阶函数+函数嵌套+闭包
上边的装饰器中用到了高阶函数和函数嵌套，没有用到闭包，但是这个装饰器就写死了，我要有传值的装饰器该怎么办呢，这时闭包的作用就来了，看下边的代码：

#做个简单的登录校验
user_dict = [
    {'name':'haha','passwd':'123456'},
    {'name':'lili','passwd':'123456'},
    {'name':'danny','passwd':'123456'},
    {'name':'jerry','passwd':'123456'},
]
current_user = {'username':None,'login':False}
def auth(auth_type='filedb'):  #达到为装饰器传参的目的
    def auth_deco(func):
        def wrapper(*args,**kwargs):
            print('-->认证类型：',auth_type)
            if auth_type == 'filedb': #当认证类型为filedb时要校验user_dict，但实际可以使用文件存储实现
                if current_user['username'] and current_user['login']:
                    res = func(*args,**kwargs)
                    return res
                username = input('用户名：').strip()
                passwd = input('密码：').strip()
                for user_list in user_dict:
                    if username == user_list['name'] and passwd == user_list['passwd']:
                        current_user['username'] = username
                        current_user['login'] = True
                        res = func(*args,**kwargs)
                        return res
                else:
                    print('用户名或密码错误，请重新登录')
            elif auth_type == 'ldap':
                print('成会玩ldap')
                res = func(*args,**kwargs)
                return res
            else:
                print('不知道你搞什么？？？')
                res = func(*args,**kwargs)
                return res
        return wrapper
    return auth_deco

@auth(auth_type='filedb') #auth_deco=auth(auth_type='filedb')-->@auth_deco(附加了一个auth_type)-->index=auth_deco(index)-->wrapper对象地址-->index()相当于运行wrapper()
def index():
    print('欢迎来到主页 %s'%name)

@auth(auth_type='ldap')
def home(name):
    print('欢迎回家 %s' %name)

@auth(auth_type='aaaaaa')
def shop(name):
    print('%s的购物车里有%s%s'%(name,'京东','妹妹'))

index()
home('haha')
shop('lili')

以上代码通过装饰器实现了一个简单的验证功能，利用闭包将认证类型传入装饰器中的嵌套函数，这就实现了闭包：内部函数应用外部函数的变量。下边具体了解下装饰器的分类：

函数装饰器

#####函数的函数装饰器########
 import time

def decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        func()
        end_time = time.time()
        print(end_time - start_time)

    return wrapper

@decorator 
def func():
    time.sleep(0.8)

func() # 函数调用
# 输出：0.800644397735595

在上面代码中 func是我要装饰器的函数，我想用装饰器显示func函数运行的时间。@decorator这个语法相当于 执行 func = decorator(func)，为func函数装饰并返回。在来看一下我们的装饰器函数 - decorator，该函数的传入参数是func （被装饰函数），返回参数是内层函数。这里的内层函数-wrapper，其实就相当于闭包函数，它起到装饰给定函数的作用，wrapper参数为*args, **kwargs。*args表示的参数以列表的形式传入；**kwargs表示的参数以字典的形式传入；

##########类方法的函数装饰器##############
######类方法的函数装饰器和函数的函数装饰器类似
import time

def decorator(func):
    def wrapper(me_instance):
        start_time = time.time()
        func(me_instance)
        end_time = time.time()
        print(end_time - start_time)
    return wrapper

class Method(object):

    @decorator 
    def func(self):
        time.sleep(0.8)

p1 = Method()
p1.func() # 函数调用

对于类方法来说，都会有一个默认的参数self，它实际表示的是类的一个实例，所以在装饰器的内部函数wrapper也要传入一个参数 - me_instance就表示将类的实例p1传给wrapper，其他的用法都和函数装饰器相同。

类装饰器

前面我们提到的都是让 函数作为装饰器去装饰其他的函数或者方法，那么可不可以让 一个类发挥装饰器的作用呢？答案肯定是可以的，一切皆对象嘛，函数和类本质没有什么不一样。类的装饰器是什么样子的呢？

 class Decorator(object):
    def __init__(self, f):
        self.f = f
    def __call__(self):
        print("decorator start")
        self.f()
        print("decorator end")

@Decorator
def func():
    print("func")

func()
#__call__()是一个特殊方法，它可将一个类实例变成一个可调用对象:
p = Decorator(func) # p是类Decorator的一个实例
p() # 实现了__call__()方法后，p可以被调用

python 自带的一些装饰器

静态属性：即数据属性，类提供装饰器@property将函数属性变成数据属性，实例对象在调用函数属性的时候不用加()了，直接 . 函数名就好了；property可以将函数逻辑给封装起来，调用时感受不到；跟实例绑定；
类方法：@classmethod装饰的方法称为类方法，该方法可供类使用，不需要实例，方法中自动参数（cls）,该参数自动接收类名，跟类绑定；
静态方法：@staticmethod，不再绑定实例或者类，不能调用类变量和实例变量，是类的工具包；