装饰器

import time
def timmer():
    start = time.time()
    func()
    end = time.time()
    print(end-start)
# print(time.time()) # 从1970年到现在过来多少秒 1581672299.4920743
def func():
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')
timmer()

#=========================================

import time
def timmer(f):
    start = time.time()
    f()
    end = time.time()
    print(end-start)
# print(time.time()) # 从1970年到现在过来多少秒 1581672299.4920743
def func():
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')
timmer(func)
调用timmer函数， 将func函数的地址作为参数 传给 timmer函数，达到调用func函数的目的。

#---------------------------------------------------------

如果计算200个函数的执行时间怎么办

import time
def func():  # 被装饰函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')

def timmer(f): #装饰器函数
    def inner():
        start = time.time()
        f() # 被装饰的函数
        end = time.time()
        print(end-start)
    return inner
func1 = timmer(func)
func1() # inner()
 解释：首先程序执行是从上到下的执行
1、import time
2、def func()
3、def timmer(f)
4、timmer(func) 执行函数内部，且将 func的地址作为参数传给timmer
5、def inner():
6、return inner，且将inner地址赋值给 func1
7、func1() = inner()，执行inner内部 ，执行func()函数，print(end-start)


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


# 装饰器的作用就是不需要修改别人的程序或者已有的程序来增加新的功能
# timmer就是一个装饰器函数，只是对一个函数 有一些装饰作用


#-----------------------------------------------------------------

import time
def timmer(f): #装饰器函数
    def inner():
        start = time.time()
        f() # 执行func函数
        end = time.time()
        print(end-start)
    return inner
@timmer #   func = timmer(func) 语法糖
def func(): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')
func()
# @timmer         #语法糖 @装饰器函数名

#----------------------------------------------------------

import time
def timmer(f): #装饰器函数
    def inner():
        start = time.time()
        f() # 执行func函数 结果就是 print('新年好')
        end = time.time()
        print(end-start)
        return f() # 首先调用func函数，并返回return '早日打赢新冠疫情'。
    return inner # 返回inner函数地址
@timmer #   func = timmer(func) 语法糖
def func(): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')
    return '早日打赢新冠疫情'
ret = func() # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
print(ret)


#-----------------------------------------------------------------
#
import time
def timmer(f): #装饰器函数
    def inner():
        start = time.time()
        ret = f() # 执行func函数 结果就是 print('新年好'),并接收返回值 '早日打赢新冠疫情' 赋给ret
        end = time.time()
        print(end-start)
        return ret # 首先调用func函数，并返回return '早日打赢新冠疫情'。
    return inner # 返回inner函数地址
@timmer #   func = timmer(func) 语法糖
def func(): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好')
    return '早日打赢新冠疫情'
ret = func() # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
print(ret)

#=========================================================================

#被装饰函数 带参数， 1 传给inner的b，f()可以使用 inner的b作为参数，调用func()带b参数，b 传给a

import time
def timmer(f): #装饰器函数
    def inner(b):
        start = time.time()
        ret = f(b) # 执行func函数 结果就是 print('新年好'),并接收返回值 '早日打赢新冠疫情' 赋给ret
        end = time.time()
        print(end-start)
        return ret # 首先调用func函数，并返回return '早日打赢新冠疫情'。
    return inner # 返回inner函数地址
@timmer #   func = timmer(func) 语法糖
def func(a): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好',a)
    return '早日打赢新冠疫情'
ret = func(1) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
print(ret)

#--------------------------------------------------------------------------
# #要求都被timmer计算长短，要求一个传一个参数，另一个传2个参数
#
import time
def timmer(f): #装饰器函数
    def inner(*args,**kwargs):
        start = time.time()
        ret = f(*args,**kwargs) # 执行func函数 结果就是 print('新年好'),并接收返回值 '早日打赢新冠疫情' 赋给ret
        end = time.time()
        print(end-start)
        return ret # 首先调用func函数，并返回return '早日打赢新冠疫情'。
    return inner # 返回inner函数地址

@timmer #   func = timmer(func) 语法糖
def func(a,b): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好',a,b)
    return '早日打赢新冠疫情'

ret = func(1,2) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
ret2 = func(5,b=6)
print(ret,ret2)

@timmer #   func1 = timmer(func1) 语法糖
def func1(a): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好',a)
    return '林集加油'
ret = func1(3) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
print(ret)



#-----------------------------------------------------------------------------------------

import time
def timmer(f): #装饰器函数
    def inner(*args,**kwargs):
        start = time.time()
        ret = f(*args,**kwargs) # 执行func函数 结果就是 print('新年好'),并接收返回值 '早日打赢新冠疫情' 赋给ret
        end = time.time()
        print(end-start)
        return ret # 首先调用func函数，并返回return '早日打赢新冠疫情'。
    return inner # 返回inner函数地址

@timmer #   func = timmer(func) 语法糖
def func(*args,**kwargs): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好',args,kwargs)
    return '早日打赢新冠疫情'

ret = func(1,2) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
ret2 = func(5,b=6,c=9)
print(ret,ret2)

@timmer #   func1 = timmer(func1) 语法糖
def func1(a): # 被装饰的函数
    time.sleep(0.01)  # 让程序在执行的这个位置停一会
    print('新年好',a)
    return '林集加油'
ret = func1(3) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情
print(ret)
结果：
新年好 (1, 2) {}
0.010235309600830078
新年好 (5,) {'b': 6, 'c': 9}
0.010958433151245117
早日打赢新冠疫情 早日打赢新冠疫情
新年好 3
0.010042905807495117
林集加油

#===============================================================



def timmer(f): #装饰器函数
    def inner(*args,**kwargs):

        ret = f(*args,**kwargs) #

        return ret #
    return inner # 返回inner函数地址
@timmer #   func = timmer(func) 语法糖
def func(a,b): # 被装饰的函数

    print('新年好',a,b)
 # func = timmer(func) 语法糖
ret = func(1,2) # 这里的func就是inner ，执行inner函数，并返回 f()返回值 早日打赢新冠疫情

#=============================================================

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 '新年好'
ret = func(1,2)
print(ret)

# ------------------------------------------------

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

@wrapper #   qqxing = wrapper(qqxing)
def qqxing():
    print(123)
# qqxing = wrapper(qqxing)
ret = qqxing() #  在@wrapper之后qqxing就是inner()
print(ret)