1.對大批量函數添加裝飾器，而且不定期的開關

# 多個裝飾器，添加批量管理的開關
import time
FLAG = False
def outer(flag):
    def timer(f1):
        def inner(*args,**kwargs):
            if flag == True:
                start_time = time.time()
                ret = f1(*args,**kwargs)
                end_time = time.time()
                
 
print(‘運行時間為 %s‘ % (end_time-start_time))
            else:
                ret = f1(*args,**kwargs)
            return ret
        return inner
    return timer

@outer(FLAG)
def func1(a, b):
    print(‘func1開頭 -- %s‘ % a)
    time.sleep(0.1)
    print(‘func1結尾 -- %s‘ % b)

@outer(FLAG)
def func2(a, b):
    
 
print(‘func2開頭 -- %s‘ % a)
    time.sleep(0.1)
    print(‘func2結尾 -- %s‘ % b)
# func1開頭 -- a
# func1結尾 -- b
# func2開頭 -- c
# func2結尾 -- d

2.使用裝飾器進行登錄檢測

# 第二種情況
# 使用裝飾器進行登陸檢測，如果已經登陸，則不用再次登陸
#
import time
login_info = {‘alex‘:False}

def login(func1):
    def inner(name):
        
 
if login_info[name] != True:
            user = input(‘user: ‘)
            pwd = input(‘pwd: ‘)
            if user == ‘alex‘ and pwd == ‘alex3714‘:
                login_info[name] = True
        if login_info[name] == True:
            ret = func1(name)
            return ret
    return inner

def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print(end_time-start_time)
        return ret
    return inner


@login # index = login(index) -- inner
@timmer
def index(name):
    print(‘歡迎%s來到博客園首頁---‘ % name)
    time.sleep(0.3)

@login
@timmer
def manager(name):
    print(‘歡迎%s來到博客園管理界面---‘ % name)
    time.sleep(0.3)


index(‘alex‘)
manager(‘alex‘)
index(‘alex‘)
manager(‘alex‘)

# user: alex
# pwd: alex3714
# 歡迎alex來到博客園首頁---
# 0.30012965202331543
# 歡迎alex來到博客園管理界面---
# 0.30124926567077637
# 歡迎alex來到博客園首頁---
# 0.3006711006164551
# 歡迎alex來到博客園管理界面---
# 0.3006777763366699

3.多個裝飾器裝飾一個函數，結構類似套娃

# 多個裝飾器裝飾一個函數，結構類似於套娃結構
def wrapper1(f1): #f
    def inner1():
        print(‘wrapper1 before func‘)
        f1() # f
        print(‘wrapper1 after func‘)
    return inner1

def wrapper2(f2): #inner
    def inner2():
        print(‘wrapper2 before func‘)
        f2() # inner1
        print(‘wrapper2 after func‘)
    return inner2

# 在裝飾器執行的時候，是從下向上依次執行
@wrapper2 # f = wrapper2(inner1) --> inner2
@wrapper1 # f = wrapper1(f) --> inner1
def f():
    print(‘in f‘)

f()  #inner2
# wrapper2 before func
# wrapper1 before func
# in f
# wrapper1 after func
# wrapper2 after func

# 運行過程
def wrapper1(f1): # 3- f1 = f
    def inner1():
        print(‘wrapper1 before func‘) ## 14=
        f1() ## 15= f()
        print(‘wrapper1 after func‘) ## 17=
    return inner1  # 4- inner1

def wrapper2(f2): # 7- f2 = inner1
    def inner2():  ## 11=
        print(‘wrapper2 before func‘) ## 12=
        f2() ## 13= inner1
        print(‘wrapper2 after func‘) ## 18=
    return inner2  # 8- inner2

# 在裝飾器執行的時候，是從下向上依次執行

# 當遇到多個裝飾器裝飾一個函數的時候，會一直向下走，直到找到被裝飾的函數
# 是一個先往下走，再往上回的過程
@wrapper2 # 6- f = wrapper2(f) --> f = wrapper2(inner1) # 9- f = inner2 **** 裝飾過程結束
@wrapper1 # 2- f = wrapper1(f)  # 5- f = inner1 --> f
def f(): # 1- 從找到的f開始
    print(‘in f‘) ## 16=

f()  # 10- 開始調用 f()相當於inner2()

第五章 裝飾器進階