『Python終結(jié)者 #4』裝飾器，也叫Decorator
回復(fù)“書籍”即可獲贈(zèng)Python從入門到進(jìn)階共10本電子書
之前發(fā)過兩篇裝飾器的文章，當(dāng)時(shí)為了博取眼球，標(biāo)題取得虛頭巴腦。現(xiàn)在把兩篇合并在一起，重新發(fā)在『Python終結(jié)者』系列中，方便大家學(xué)習(xí)。
前不久，我面試過一個(gè)要求月薪30k+的程序員，還有一個(gè)浙大畢業(yè)的新人，兩個(gè)人都自稱最熟悉的編程語言是Python，但沒有一個(gè)人知道裝飾器。看完這篇文章，至少你在這方面超越了他們。
看透這篇文章，你至少超過了80%的Python學(xué)習(xí)者。
就算一周學(xué)透一個(gè)重要知識(shí)點(diǎn)，不久之后，你就會(huì)成為很厲害的存在！加油！！
對(duì)于Python學(xué)習(xí)者，一旦過了入門階段，你幾乎一定會(huì)用到Python的裝飾器。
它經(jīng)常使用在很多地方，比如Web開發(fā)，日志處理，性能搜集，權(quán)限控制等。
還有一個(gè)極其重要的地方，那就是面試的時(shí)候。對(duì)，裝飾器是面試中最常見的問題之一！
實(shí)戰(zhàn)入門
拋出問題
看這段代碼：
def step1():
print('step1.......')
def step2():
print('step2......')
def step3():
print('step3......')
step1()
step2()
step3()
代碼中定義了3個(gè)函數(shù)，然后分別調(diào)用這3個(gè)函數(shù)。假設(shè)，我們發(fā)現(xiàn)代碼運(yùn)行很慢，我們想知道每個(gè)函數(shù)運(yùn)行分別花了多少時(shí)間。
笨辦法解決
我們可以在每個(gè)函數(shù)中添加計(jì)時(shí)的代碼：
第一行記錄開始時(shí)間 執(zhí)行完業(yè)務(wù)邏輯記錄結(jié)束時(shí)間 結(jié)束時(shí)間減去開始時(shí)間，算出函數(shù)執(zhí)行用時(shí)
下面的例子只在step1中添加了相關(guān)代碼作為示例，你可以自行給step2和step3添加相關(guān)代碼。
import time
def step1():
start = time.time()
print('step1.......')
end = time.time()
used = end - start
print(used)
def step2():
print('step2......')
def step3():
print('step3......')
step1()
step2()
step3()
這個(gè)方法可行！但用你的腳指頭想想也會(huì)覺得，這個(gè)方法很繁瑣，很笨拙，很危險(xiǎn)！
這里只有3個(gè)函數(shù)，如果有30個(gè)函數(shù)，那不是要死人啦。萬一修改的時(shí)候不小心，把原來的函數(shù)給改壞了，面子都丟光了，就要被人BS了！
一定有一個(gè)更好的解決方法！
用裝飾器解決
更好的解決方法是使用裝飾器。
裝飾器并沒有什么高深的語法，它就是一個(gè)實(shí)現(xiàn)了給現(xiàn)有函數(shù)添加裝飾功能的函數(shù)，僅此而已！
import time
def timer(func):
'''統(tǒng)計(jì)函數(shù)運(yùn)行時(shí)間的裝飾器'''
def wrapper():
start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}')
return wrapper
def step1():
print('step1.......')
def step2():
print('step2......')
def step3():
print('step3......')
timed_step1 = timer(step1)
timed_step2 = timer(step2)
timed_step3 = timer(step3)
timed_step1()
timed_step2()
timed_step3()
上面的timer函數(shù)就是個(gè)裝飾器。
它的參數(shù)是需要被裝飾的函數(shù) 返回值是新定義的一個(gè)包裝了原有函數(shù)的函數(shù)。 新定義的函數(shù)先記錄開始時(shí)間，調(diào)用被裝飾的函數(shù)，然后再計(jì)算用了多少時(shí)間。
簡單說就是把原來的函數(shù)給包了起來，在不改變?cè)瘮?shù)代碼的情況下，在外面起到了裝飾作用，這就是傳說中的裝飾器。它其實(shí)就是個(gè)普通的函數(shù)。
如果你覺得有點(diǎn)懵逼，需要加強(qiáng)一些對(duì)Python函數(shù)的理解。函數(shù)：
可以作為參數(shù)傳遞 可以作為返回值 也可以定義在函數(shù)內(nèi)部
要深入了解函數(shù)，請(qǐng)關(guān)注我的公眾號(hào)：麥?zhǔn)寰幊獭?/p>
然后，我們不再直接調(diào)用step1, 而是：
先調(diào)用timer函數(shù)，生成一個(gè)包裝了step1的新的函數(shù)timed_step1. 剩下的就是調(diào)用這個(gè)新的函數(shù)time_step1()，它會(huì)幫我們記錄時(shí)間。
timed_step1 = timer(step1)
timed_step1()
簡潔點(diǎn)，也可以這樣寫:
timer(step1)()
timer(step2)()
timer(step3)()
這樣可以在不修改原有函數(shù)代碼的情況下，給函數(shù)添加了裝飾性的新功能。
但是仍然需要修改調(diào)用函數(shù)的地方，看起來還不夠簡潔。有沒有更好的辦法呢？當(dāng)然是有的！
裝飾器語法糖衣
我們可以在被裝飾的函數(shù)前使用@符號(hào)指定裝飾器。這樣就不用修改調(diào)用的地方了，這個(gè)世界清凈了。下面的代碼和上一段代碼功能一樣。在運(yùn)行程序的時(shí)候，Python解釋器會(huì)根據(jù)@標(biāo)注自動(dòng)生成裝飾器函數(shù)，并調(diào)用裝飾器函數(shù)。
import time
def timer(func):
'''統(tǒng)計(jì)函數(shù)運(yùn)行時(shí)間的裝飾器'''
def wrapper():
start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}')
return wrapper
@timer
def step1():
print('step1.......')
@timer
def step2():
print('step2......')
@timer
def step3():
print('step3......')
step1()
step2()
step3()
到了這里，裝飾器的核心概念就講完了。
剩下的基本都是在不同場(chǎng)合下的應(yīng)用。如果你是大忙人，不想學(xué)的太深，可以搜藏本文章，以后再回來看。
但是記得點(diǎn)在看。據(jù)說點(diǎn)了得都變帥了，也找到了好工作，或者升職加薪了。
進(jìn)階用法
上面是一個(gè)最簡單的例子，被裝飾的函數(shù)既沒有參數(shù)，也沒有返回值。下面來看有參數(shù)和返回值的情況。
帶參數(shù)的函數(shù)
我們把step1修改一下，傳入一個(gè)參數(shù)，表示要走幾步。
import time
def timer(func):
'''統(tǒng)計(jì)函數(shù)運(yùn)行時(shí)間的裝飾器'''
def wrapper():
start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}')
return wrapper
@timer
def step1(num):
print(f'我走了#{num}步')
step1(5)
再去運(yùn)行，就報(bào)錯(cuò)了：
TypeError: wrapper() takes 0 positional arguments but 1 was given
這是因?yàn)椋砻嫔衔覀儗懙氖莝tep1(5)，實(shí)際上Python是先調(diào)用wrapper()函數(shù)。這個(gè)函數(shù)不接受參數(shù)，所以報(bào)錯(cuò)了。
為了解決這個(gè)問題，我們只要給wrapper加上參數(shù)就可以。
import time
def timer(func):
'''統(tǒng)計(jì)函數(shù)運(yùn)行時(shí)間的裝飾器'''
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
end = time.time()
used = end - start
print(f'{func.__name__} used {used}')
return wrapper
wrapper使用了通配符，*args代表所有的位置參數(shù)，**kwargs代表所有的關(guān)鍵詞參數(shù)。這樣就可以應(yīng)對(duì)任何參數(shù)情況。 wrapper調(diào)用被裝飾的函數(shù)的時(shí)候，只要原封不動(dòng)的把參數(shù)再傳遞進(jìn)去就可以了。
如果對(duì)關(guān)鍵詞參數(shù)和位置參數(shù)不明白，可以在B站搜索"麥?zhǔn)?參數(shù)"，學(xué)習(xí)相關(guān)視頻。
函數(shù)返回值
如果被裝飾的函數(shù)func有返回值，wrapper也只需把func的返回值返回就可以了。
import time
def timer(func):
'''統(tǒng)計(jì)函數(shù)運(yùn)行時(shí)間的裝飾器'''
def wrapper(*args, **kwargs):
start = time.time()
ret_value = func(*args, **kwargs)
end = time.time()
used = end - start
print(f'{func.__name__} used {used}')
return ret_value
return wrapper
@timer
def add(num1, num2):
return num1 + num2
sum = add(5, 8)
print(sum)
這里我新加了一個(gè)add函數(shù)，計(jì)算兩個(gè)數(shù)之和。
在wrapper函數(shù)中，我們先保存了func的返回值到ret_value，然后在wrapper的最后返回這個(gè)值就可以了。
到這里，你又進(jìn)了一步，你可以擊敗88.64%的Python學(xué)習(xí)者了。但還不夠，后面還有：
類裝飾器(上面都是函數(shù)裝飾器) 多裝飾器串聯(lián) 帶參數(shù)的裝飾器（不同于上面的帶參數(shù)的函數(shù)） 帶狀態(tài)的裝飾器 用類封裝裝飾器 裝飾器常用情況舉例
有位同學(xué)看完前面的內(nèi)容，覺得自己掌握的很好了，就去面試。
結(jié)果被面試官一個(gè)“如何在Python中實(shí)現(xiàn)單例模式”的問題給當(dāng)場(chǎng)問倒了。
氣得他上去就是兩個(gè)耳刮子，不過不是打面試官，是打自己，恨自己沒有等讀透整篇再去面試。所以大家都耐心讀完。
你一定用過裝飾器Decorator
其實(shí)Decorator就在我們身邊，只是我們可能不知道它們是裝飾器。我來說幾個(gè)：@classmethod @staticmethod @property
有沒有一種"我靠"的沖動(dòng)？！
對(duì)，這些很重要的語法，不過是裝飾器的應(yīng)用而已。
來看一個(gè)代碼例子：
class Circle:
#半徑用下劃線開頭，表示私有變量
def __init__(self, radius):
self._radius = radius
#用property裝飾器創(chuàng)建虛擬的半徑屬性
@property
def radius(self):
return self._radius
#用setter裝飾器給半徑屬性添加賦值操作
@radius.setter
def radius(self, value):
if value >= 0:
self._radius = value
else:
raise ValueError("Radius must be positive")
#用property裝飾器創(chuàng)建虛擬的面積屬性
@property
def area(self):
return self.pi() * self.radius**2
def cylinder_volume(self, height):
return self.area * height
#類方法
@classmethod
def unit_circle(cls):
return cls(1)
#靜態(tài)方法
@staticmethod
def pi():
return 3.1415926535
再來創(chuàng)建兩個(gè)裝飾器練練手
你不要以為你已經(jīng)掌握了裝飾器，你只是聽懂了。
從聽懂到能動(dòng)手寫出來，再到被面試的時(shí)候，可以流暢的說出來，那還差著二十萬八千里呢！
一定得多動(dòng)手！所以抓緊時(shí)間，馬上再來創(chuàng)建兩個(gè)裝飾器。
代碼調(diào)試裝飾器
現(xiàn)在我們來創(chuàng)建一個(gè)裝飾器：它會(huì)打印函數(shù)的參數(shù)，以及返回值。
如果你有實(shí)際項(xiàng)目經(jīng)驗(yàn)，你一定會(huì)知道這個(gè)很有用。這不就是自動(dòng)打印日志嘛！是程序員找臭蟲的必備良藥啊。
來看看代碼：
def debug(func):
def wrapper_debug(*args, **kwargs):
print(f'{func.__name__}:{args}, {kwargs}')
ret_val = func(*args, **kwargs)
print(f'return: {ret_val}')
return ret_val
return wrapper_debug
@debug
def add(a, b):
return a + b
add(1, 3)
add(2, 3)
add(4, 3)
在wrapper_debug函數(shù)中，我們先打印所有的參數(shù)，再調(diào)用原函數(shù)，最后先打印返回值，再返回返回值。這里并沒有新的語法知識(shí)，就是為了練手。
裝B神奇 - 讓程序跑慢點(diǎn)
曾經(jīng)我還年輕，看到一個(gè)大神的代碼里面有這么一行：
sleep(random(1,5))
因?yàn)橛辛诉@行代碼，程序運(yùn)行的時(shí)候挺慢的。我就問大神，為什么要這樣。大神語重心長的跟我說：
你還年輕！我把這個(gè)程序交付給客戶，客戶會(huì)覺得有點(diǎn)慢，但還能忍。
忍不住了，會(huì)來找我優(yōu)化性能。我一個(gè)手指頭就把性能優(yōu)化上去了，客戶一定對(duì)我五體投地。而且我們公司的尾款也給我們了。
年輕人，多學(xué)著點(diǎn)！這就是閱歷，閱歷！
可惜我學(xué)了這么多年，也沒學(xué)會(huì)這種閱歷。
不過有時(shí)候，因?yàn)楦鞣N原因，我們確實(shí)需要讓程序變慢一點(diǎn)。裝飾器就排上了用場(chǎng)：
import time
def slow(func):
def wrapper_slow(*args, **kwargs):
print(f'{func.__name__} sleeping 1 second')
time.sleep(1)
ret_val = func(*args, **kwargs)
return ret_val
return wrapper_slow
@slow
def add(a, b):
return a + b
add(1, 3)
運(yùn)行一下，你就會(huì)很有成就感！確實(shí)慢！
上面那個(gè)真實(shí)的段子，我勸大家和我一樣，一直都學(xué)不會(huì)。日久見人心，坑人的事情不能干。
裝飾器模板
經(jīng)過前面幾個(gè)例子，我們可以總結(jié)出一個(gè)裝飾器的模板。
按照這個(gè)模板，可以輕松寫出裝飾器：
def decorator(func):
def wrapper_decorator(*args, **kwargs):
#調(diào)用前操作
ret_val = func(*args, **kwargs)
#調(diào)用后操作
return ret_val
return wrapper_decorator
按照這個(gè)模板：
修改裝飾器的名字，把decorator替換為具體的名字。 在注釋“調(diào)用前操作”的地方寫自己想寫的代碼 在注釋“調(diào)用后操作”的地方寫自己想寫的代碼。
帶參數(shù)的裝飾器
上面那兩個(gè)都是普通的裝飾器的應(yīng)用，我們不能繼續(xù)自High下去了。我們得學(xué)習(xí)新知識(shí)了。
上面那個(gè)slow的裝飾器，如果能夠傳入到底要sleep幾秒就好了，現(xiàn)在是固定的1秒，這個(gè)不香。
注意區(qū)分，這里的參數(shù)是指裝飾器的參數(shù)。和前面提到的函數(shù)自身的參數(shù)是不同的。
我想讓它多慢就多慢，然后我們?cè)夙暱涕g扭轉(zhuǎn)乾坤，這樣客戶就更為我神魂顛倒了。
要讓裝飾器接受參數(shù)，需要在普通裝飾器的外面再套上一層：
import time
def slow(seconds):
def decorator_slow(func):
def wrapper_slow(*args, **kwargs):
print(f'{func.__name__} sleeping {seconds} second')
time.sleep(seconds)
ret_val = func(*args, **kwargs)
return ret_val
return wrapper_slow
return decorator_slow
#添加裝飾器的時(shí)候可以傳入要放慢幾秒的參數(shù)。@slow(2)def add(a, b):
return a + b
#執(zhí)行此行會(huì)停頓2秒
add(1, 3)以前的裝飾器，是函數(shù)里面有一個(gè)內(nèi)部函數(shù)（2層函數(shù)），現(xiàn)在這個(gè)有了3層函數(shù)：
先是slow，接受秒數(shù)作為參數(shù) slow里面創(chuàng)建了decorator_slow函數(shù)，這個(gè)就是和原來一樣的裝飾器函數(shù) wrapper_slow里面又創(chuàng)建了wrapper_slow函數(shù)。
其實(shí)后面兩層就是和之前一樣的，唯一的區(qū)別是外面又加了一層。
為什么會(huì)這樣呢？為什么最外面一層不需要傳入func參數(shù)呢？
這是因?yàn)椋?/p>
當(dāng)Python發(fā)現(xiàn)slow(2)這個(gè)裝飾器自帶了參數(shù)時(shí)，它就不再傳入當(dāng)前函數(shù)作為參數(shù)，直接調(diào)用slow。這是Python解釋器規(guī)定的。 slow返回了一個(gè)函數(shù)，這時(shí)候Python會(huì)再把當(dāng)前函數(shù)傳入進(jìn)去，這時(shí)候就成為一個(gè)普通的裝飾器了。
這就是說最外面一層的功能就是為了處理裝飾器的參數(shù)的。
如果你一下子不能理解，先把代碼敲出來，你就理解了。正所謂：熟讀唐詩三百首，不會(huì)吟詩也會(huì)吟！
再來看一個(gè)裝飾器帶參數(shù)的例子：
def repeat(nums=3):
def decorator_repeat(func):
def wrapper_repeat(*args, **kwargs):
for _ in range(nums):
func(*args, **kwargs)
return wrapper_repeat
return decorator_repeat
@repeat(3)
def run():
print('跑步有利于身體健康，來一圈')
#這里會(huì)重復(fù)執(zhí)行3次
run()
這個(gè)裝飾和slow裝飾器一樣坑人，它會(huì)多次重復(fù)執(zhí)行一個(gè)方法，并且可以動(dòng)態(tài)指定要重復(fù)幾次。
細(xì)細(xì)品味一下這個(gè)3層的函數(shù)，它是如何實(shí)現(xiàn)帶參數(shù)的裝飾器的。這兩個(gè)例子都懂了，你就走在吊打面試官的路上了。
類裝飾器
還記得前面給自己兩個(gè)耳光的同學(xué)嗎？如果他現(xiàn)在去面試，還是給自己兩個(gè)耳光，還是不知道如何實(shí)現(xiàn)單例模式。
單例模式，是指一個(gè)類只能創(chuàng)建一個(gè)實(shí)例，是最常見的設(shè)計(jì)模式之一。
比如網(wǎng)站程序有一個(gè)類統(tǒng)計(jì)網(wǎng)站的訪問人數(shù)，這個(gè)類只能有一個(gè)實(shí)例。如果每次訪問都創(chuàng)建一個(gè)新的實(shí)例，那人數(shù)就永遠(yuǎn)是1了。
在Python中可以用裝飾器實(shí)現(xiàn)單例模式。
前面的裝飾器都是用來裝飾函數(shù)的，或者用來裝飾類方法的，比如我們寫的slow, debug, timer; Python自帶的staticmethod, classmethod等。
那如果把裝飾器放到類名前面會(huì)怎樣呢？來看這段代碼：
from slow import slow
@slow
class Counter():
def __init__(self):
self._count = 0
def visit(self):
self._count += 1
print(f'visiting: {self._count}')
c1 = Counter()
c1.visit()
c1.visit()
c2 = Counter()
c2.visit()
c2.visit()
這個(gè)類名叫Counter()，顧名思義就是用來做計(jì)數(shù)的。它有一個(gè)內(nèi)部變量叫做_count，每次調(diào)用Counter的visit()方法，計(jì)數(shù)就會(huì)加1.
第一行，我們引入了前面寫的slow裝飾器，是那個(gè)普通的不帶參數(shù)的slow。裝飾器就是個(gè)函數(shù)，當(dāng)然可以被import進(jìn)來。
這次@slow放在Counter類名前面，而不是方法的前面，會(huì)發(fā)生什么呢？運(yùn)行上面的代碼，會(huì)發(fā)現(xiàn)這樣的結(jié)果：
Counter sleeping 1 second
visiting: 1
visiting: 2
Counter sleeping 1 second
visiting: 1
visiting: 2
這說明只有在創(chuàng)建Counter實(shí)例的時(shí)候，才會(huì)sleep一秒，調(diào)用visit函數(shù)的時(shí)候，不會(huì)sleep。
所以，類裝飾器實(shí)際上裝飾的是類的初始化方法。只有初始化的時(shí)候會(huì)裝飾一次。
用裝飾器實(shí)現(xiàn)單例模式
上面的運(yùn)行結(jié)果很讓人失望，如果去面試，還是會(huì)給自己兩個(gè)耳刮子的。
作為一個(gè)計(jì)數(shù)器，應(yīng)該計(jì)數(shù)是不斷疊加的。
可是上面的代碼，創(chuàng)建了兩個(gè)計(jì)數(shù)器，自己記錄自己的。扯淡啊！
我們現(xiàn)在就用類裝飾器改造它:
def singleton(cls):
'''創(chuàng)建一個(gè)單例模式'''
def single_wrapper(*args, **kwargs):
if not single_wrapper.instance:
single_wrapper.instance = cls(*args, **kwargs)
return single_wrapper.instance
single_wrapper.instance = None
return single_wrapper
@singleton
class Counter():
def __init__(self):
self._count = 0
def visit(self):
self._count += 1
print(f'visiting: {self._count}')
c1 = Counter()
c1.visit()
c1.visit()
c2 = Counter()
c2.visit()
c2.visit()
先來運(yùn)行一下：
visiting: 1
visiting: 2
visiting: 3
visiting: 4
結(jié)果很滿意，雖然創(chuàng)建了兩個(gè)Counter，計(jì)數(shù)是記錄在一起的。這主要得益于這個(gè)新的裝飾器：
def singleton(cls):
'''創(chuàng)建一個(gè)單例模式'''
def single_wrapper(*args, **kwargs):
#如果沒有實(shí)例，則創(chuàng)建實(shí)例
if not single_wrapper.instance:
single_wrapper.instance = cls(*args, **kwargs)
#返回原來的實(shí)例，或者新的實(shí)例
return single_wrapper.instance
#給新創(chuàng)建的函數(shù)添加一個(gè)屬性保存實(shí)例
single_wrapper.instance = None
return single_wrapper
它和其他的裝飾器基本一樣，它的不同之處在于這一行：
single_wrapper.instance = None
在創(chuàng)建完函數(shù)后，又給函數(shù)添加了一個(gè)屬性，用來保存實(shí)例，開始為None，就是沒有實(shí)例。
再來分析一下代碼邏輯：
先判斷是否有實(shí)例，如果沒有就創(chuàng)建一個(gè)。反過來，已經(jīng)有了就不用創(chuàng)建。 返回實(shí)例。
把這個(gè)裝飾器加到類上的時(shí)候，就相當(dāng)于加到了初始化方法。
當(dāng)我們創(chuàng)建Counter的時(shí)候，被這個(gè)裝飾器截胡，它會(huì)返回一個(gè)已經(jīng)創(chuàng)建好的實(shí)例。如果沒有實(shí)例，它會(huì)創(chuàng)建一個(gè)。
也就是說，不管調(diào)用Counter()多少次，最終就只有一個(gè)實(shí)例。這就是實(shí)現(xiàn)了單例模式。
如果有點(diǎn)不懂，再看一遍，為的是在面試官面前揚(yáng)眉吐氣。
帶狀態(tài)的裝飾器
上面的例子中，我們看到裝飾器自己保存了一個(gè)實(shí)例，你要的時(shí)候它就給你這一個(gè)，所以才實(shí)現(xiàn)了單例模式。這種就叫做帶狀態(tài)的裝飾器。
我們?cè)賮砜匆粋€(gè)例子。count裝飾器會(huì)記錄一個(gè)函數(shù)被調(diào)用的次數(shù)：
def count(func):
def wrapper_count():
wrapper_count.count += 1
print(f'{func.__name__}：第{wrapper_count.count}次調(diào)用')
func()
wrapper_count.count = 0
return wrapper_count
@count
def run():
print('跑步有利于身體健康，來一圈')
run()
run()
run()
運(yùn)行結(jié)果：
run：第1次調(diào)用
跑步有利于身體健康，來一圈
run：第2次調(diào)用
跑步有利于身體健康，來一圈
run：第3次調(diào)用
跑步有利于身體健康，來一圈
關(guān)鍵點(diǎn)就在于這一行：
wrapper_count.count = 0
給wrapper_count函數(shù)添加了count屬性，來記錄函數(shù)調(diào)用的次數(shù)，它也是一個(gè)有狀態(tài)的裝飾器。
多個(gè)裝飾器嵌套
一個(gè)函數(shù)只能有一個(gè)裝飾器嗎？
裝飾器的本質(zhì)就是先調(diào)用裝飾器，裝飾器再調(diào)用函數(shù)。既然這樣，那么多調(diào)用幾層也無妨吧。
來看這個(gè)例子：
import time
from slow import slow
def timer(func):
def wrapper():
start_time = time.perf_counter()
func()
end_time = time.perf_counter()
used_time = end_time - start_time
print(f'{func.__name__} used {used_time}')
return wrapper
@slow
@timer
def run():
print('跑步有利于身體健康，來一圈')
run()
這個(gè)例子中，run函數(shù)用了兩個(gè)裝飾器，slow和timer。它的執(zhí)行過程就相當(dāng)于：
slow(time(run()))
從上到下調(diào)用，先是調(diào)用slow，然后slow去調(diào)用timer，然后timer去調(diào)用run，所以執(zhí)行結(jié)果是：
run sleeping 1 second
跑步有利于身體健康，來一圈
wrapper_slow used 1.0026384350000002
Python裝飾器寶藏庫
差不多了，理解透這些原理，你就算不給面試官兩個(gè)耳刮子，至少也不用給自己了。相關(guān)問題就算不是對(duì)答如流，也能輕松應(yīng)對(duì)吧。
裝飾器太重要了，有很多大神寫了各種各樣的裝飾器，Python官方文檔為了一份裝飾器列表，在搜索引擎搜：PythonDecoratorLibrary。
------------------- End -------------------
往期精彩文章推薦：
歡迎大家點(diǎn)贊，留言，轉(zhuǎn)發(fā)，轉(zhuǎn)載，感謝大家的相伴與支持
想加入Python學(xué)習(xí)群請(qǐng)?jiān)诤笈_(tái)回復(fù)【入群】
萬水千山總是情，點(diǎn)個(gè)【在看】行不行
/今日留言主題/
隨便說一兩句吧~~