装饰器

装饰器形成的过程 : 最简单的装饰器 有返回值的 有一个参数 万能参数
装饰器的作用
原则 ：开放封闭原则
语法糖 ：@
装饰器的固定模式

import time
print(time.time()) # 获取当前时间
time.sleep(10)  #让程序在执行到这个位置的时候停一会儿


def timmer(f):    #装饰器函数
    def inner():
        start = time.time()
        ret = f()       #被装饰的函数
        end = time.time()
        print(end - start)
        return ret
    return inner

@timmer         #语法糖 @装饰器函数名
def func():     #被装饰的函数
    time.sleep(0.01)
    print('老板好同事好大家好')
    return '新年好'
# func = timmer(func)
ret = func()   #inner()
print(ret)

装饰器的作用 —— 不想修改函数的调用方式 但是还想在原来的函数前后添加功能
timmer就是一个装饰器函数，只是对一个函数 有一些装饰作用

原则： 开放封闭原则
开放 ： 对扩展是开放的
封闭 ： 对修改是封闭的

封版

def outer():
    def inner():
        return 'inner'
    inner()

outer()

装饰带参数函数的装饰器
def timmer(f):    #装饰器函数
    def inner(*args,**kwargs):
        #(1,2) /(1)
        start = time.time()
        ret = f(*args,**kwargs)  #f(1,2)       #被装饰的函数
        end = time.time()
        print(end - start)
        return ret
    return inner

@timmer         #语法糖 @装饰器函数名
def func(a,b):     #被装饰的函数
    time.sleep(0.01)
    print('老板好同事好大家好',a,b)
    return '新年好'

@timmer         #语法糖 @装饰器函数名
def func1(a):     #被装饰的函数
    time.sleep(0.01)
    print('老板好同事好大家好',a)
    return '新年好'
# func = timmer(func)
ret = func(1,2)   #inner()
ret = func(1,b = 2)   #inner()
print(ret)

def wrapper(f):    #装饰器函数，f是被装饰的函数
    def inner(*args,**kwargs):
        '''在被装饰函数之前要做的事'''
        ret = f(*args,**kwargs)    #被装饰的函数
        '''在被装饰函数之后要做的事'''
        return ret
    return inner

@wrapper         #语法糖 @装饰器函数名
def func(a,b):     #被装饰的函数
    time.sleep(0.01)
    print('老板好同事好大家好',a,b)
    return '新年好'

def wrapper():
    def inner():
        pass
    return inner

def wrapper(func):   #qqxing
    def inner(*args,**kwargs):
        ret = func(*args,**kwargs)   #被装饰的函数
        return ret
    return inner

@wrapper        #qqxing = wrapper(qqxing)
def qqxing():
    print(123)

ret = qqxing()   #inner

固定模式

def wrapper(f):    #装饰器函数，f是被装饰的函数
    def inner(*args,**kwargs):
        '''在被装饰函数之前要做的事'''
        ret = f(*args,**kwargs)    #被装饰的函数
        '''在被装饰函数之后要做的事'''
        return ret
    return inner

函数     函数的定义和调用   
 def 函数名(形参):
        函数体
        return 返回值
    调用 函数名(实参)
    站在形参的角度上 ： 位置参数，*args，默认参数（陷阱），**kwargs
    站在实参的角度上 ： 按照位置传，按照关键字传
    返回值：没有返回值 返回一个值 返回多个值
    接收返回值：没有返回值不接收，返回一个值用一个变量接收，返回多个值用一个变量或者对应数目的变量接收
闭包函数 —— 在内部函数引用外部函数的变量
装饰器函数—— 装饰器一定是闭包函数
    装饰器的作用 ： 在不改变原来函数的调用方式的情况下 在这个函数的前后添加新的功能
    完美的符合了一个开发原则 ：开放封闭原则
        对扩展是开放的
        对修改是封闭的

基础的装饰器

 from functools import wraps
        def wrapper(func):
            @wraps(func)
            def inner(*args,**kwargs):
                 '''在函数被调用之前添加的代码'''
                ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
                '''在函数被调用之后添加的代码'''
                return ret
            return inner
        使用 —— @wrapper
        @wrapper
        def func():   #inner
            pass

        func.__name__

带参数的装饰器

 @wrapper -- > @warapper(argument)
        三层嵌套函数
        def outer(形参):
            def wrapper(func):
                def inner(*args,**kwargs):
                    '''在函数被调用之前添加的代码'''
                    ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
                    '''在函数被调用之后添加的代码'''
                    return ret
                return inner
            return wrapper
        @outer(True)
        def func():
            pass

多个装饰器装饰一个函数

俄罗斯套娃

 def wrapper1(func):
            @wraps(func)
            def inner(*args,**kwargs):
                print('before 1')
                print('******')
                ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
                '''在函数被调用之后添加的代码'''
                return ret
    def wrapper2(func):
        @wraps(func)
        def inner(*args,**kwargs):
            print('before 2')
            ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
            '''在函数被调用之后添加的代码'''
            return ret
      @wrapper1
      @wrapper2
      def func():
          print('111')