python-------裝飾器

一、簡單的裝飾器

1.為什么要使用裝飾器呢？

　　裝飾器的功能：在不修改原函數及其調用方式的情況下對原函數功能進行擴展

　　裝飾器的本質：就是一個閉包函數

那么我們先來看一個簡單的裝飾器：實現計算每個函數的執行時間的功能

import time 
def  wrapper(func):
        def inner():
              start=time.time()
              func()
              end=time.time()
              print(end-start)
        return inner 
    
def  hahaha():
        time.sleep(1)
        print('aaaaa')
hahaha=wrapper(hahaha)
hahaha()    

上面的功能有點不簡介，不完美，下面就引進了語法糖。

import time
def wrapper(func):
        def inner():
               start=time.time()
               func()
               end=time.time()
               print(end-start)
        return inner
@wrapper
def  kkk():#相當於kkk=wrapper(kkk)
    print('aaaaa')
kkk()             

以上的裝飾器都是不帶參數的函數，現在裝飾一個帶參數的該怎么辦呢?

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

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

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

func1(1,2)
print(func2('aaaaaa'))

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

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

jjj('aaaaaa')
print(jjj('aaaaaa'))

二、開放封閉原則

1.對擴展是開放的

2.對修改是封閉的

 三、裝飾器的固定結構

import time
def wrapper(func):  # 裝飾器
    def inner(*args, **kwargs):
        '''函數執行之前的內容擴展'''
        ret = func(*args, **kwargs)
         '''函數執行之前的內容擴展'''
        return ret
    return inner

@wrapper  # =====>aaa=timmer(aaa)
def aaa():
    time.sleep(1)
    print('fdfgdg')
aaa()

 四、帶參數的裝飾器

帶參數的裝飾器：就是給裝飾器傳參

　　　　　　　　用處：就是當加了很多裝飾器的時候，現在忽然又不想加裝飾器了，想把裝飾器給去掉了，但是那么多的代碼，一個一個的去閑的麻煩，那么，我們可以利用帶參數的裝飾器去裝飾它，這就他就像一個開關一樣，要的時候就調用了，不用的時候就去掉了。給裝飾器里面傳個參數，那么那個語法糖也要帶個括號。在語法糖的括號內傳參。在這里，我們可以用三層嵌套，弄一個標識為去標識。如下面的代碼示例

# 帶參數的裝飾器：（相當於開關）為了給裝飾器傳參
# F=True#為True時就把裝飾器給加上了
F=False#為False時就把裝飾器給去掉了
def outer(flag):
    def wrapper(func):
        def inner(*args,**kwargs):
            if flag:
                print('before')
                ret=func(*args,**kwargs)
                print('after')
            else:
                ret = func(*args, **kwargs)
            return ret
        return inner
    return wrapper

@outer(F)#@wrapper
def hahaha():
    print('hahaha')

@outer(F)
def shuangwaiwai():
    print('shuangwaiwai')

hahaha()
shuangwaiwai()

 五、多個裝飾器裝飾一個函數

 

def qqqxing(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')
        return ret
    return inner

def pipixia(fun):
    def inner(*args,**kwargs):
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')
        return ret
    return inner
@qqqxing
@pipixia
def dapangxie():
    print('餓了嗎')
dapangxie()

'''
@qqqxing和@pipixia的執行順序：先執行qqqxing里面的 print('in qqxing: before')，然后跳到了pipixia里面的
        print('in qqxing: before')
        ret = fun(*args,**kwargs)
        print('in qqxing: after')，完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的運行結果截圖一樣
'''

 

 

 上例代碼的運行結果截圖

六、統計多少個函數被裝飾了的小應用

 統計多少個函數被我裝飾了
l=[]
def wrapper(fun):
    l.append(fun)#統計當前程序中有多少個函數被裝飾了
    def inner(*args,**kwargs):
        # l.append(fun)#統計本次程序執行有多少個帶裝飾器的函數被調用了
        ret = fun(*args,**kwargs)
        return ret
    return inner

@wrapper
def f1():
    print('in f1')

@wrapper
def f2():
    print('in f2')

@wrapper
def f3():
    print('in f3')
print(l)