目錄
- 1. 需求是怎么來的
- 2. 以不變應萬變，是變也
- 3. 最大限度地少改動
- 4.對帶參數的函數使用裝飾器
- 5. 給裝飾器參數
- 6.帶類參數的裝飾器
- 7. 對一個函數應用多個裝飾器
- 8. 作為一個類
1. 需求是怎么來的
裝飾器的定義很是抽象，我們來看一個小例子。
def foo():
print('in foo()')
foo()
這是一個很無聊的函數沒錯。但是突然有一個更無聊的人，我們稱呼他為B君，說我想看看執行這個函數用了多長時間，好吧，那么我們可以這樣做：
import time
def foo():
start = time.time()
print('in foo()')
time.sleep(2)
end = time.time()
print(f'used:{end - start}')
foo()
很好，功能看起來無懈可擊。可是蛋疼的B君此刻突然不想看這個函數了，他對另一個叫foo2的函數產生了更濃厚的興趣。
怎么辦呢？如果把以上新增加的代碼復制到foo2里，這就犯了大忌了~復制什么的難道不是最討厭了么！而且，如果B君繼續看了其他的函數呢？
2. 以不變應萬變，是變也
還記得嗎，函數在Python中是一等公民，那么我們可以考慮重新定義一個函數timeit，將foo的引用傳遞給他，然后在timeit中調用foo并進行計時，這樣，我們就達到了不改動foo定義的目的，而且，不論B君看了多少個函數，我們都不用去修改函數定義了！
import time
def foo():
print('in foo()')
def timeit(func):
start = time.time()
func()
time.sleep(2)
end = time.time()
print('used:', end - start)
timeit(foo)
看起來邏輯上并沒有問題，一切都很美好并且運作正常！……等等，我們似乎修改了調用部分的代碼。原本我們是這樣調用的：foo()，修改以后變成了：timeit(foo)。這樣的話，如果foo在N處都被調用了，你就不得不去修改這N處的代碼。或者更極端的，考慮其中某處調用的代碼無法修改這個情況，比如：這個函數是你交給別人使用的。
3. 最大限度地少改動
既然如此，我們就來想想辦法不修改調用的代碼；如果不修改調用代碼，也就意味著調用foo()需要產生調用timeit(foo)的效果。我們可以想到將timeit賦值給foo，但是timeit似乎帶有一個參數……想辦法把參數統一吧！如果timeit(foo)不是直接產生調用效果，而是返回一個與foo參數列表一致的函數的話……就很好辦了，將timeit(foo)的返回值賦值給foo，然后，調用foo()的代碼完全不用修改！
# -*- coding: UTF-8 -*-
import time
def foo():
print('in foo()')
# 定義一個計時器，傳入一個，并返回另一個附加了計時功能的方法
def timeit(func):
# 定義一個內嵌的包裝函數，給傳入的函數加上計時功能的包裝
def wrapper():
start = time.time()
func()
time.sleep(2)
end = time.time()
print('used:', end - start)
# 將包裝后的函數返回
return wrapper
foo = timeit(foo)
foo()
這樣，一個簡易的計時器就做好了！我們只需要在定義foo以后調用foo之前，加上foo = timeit(foo)，就可以達到計時的目的，這也就是裝飾器的概念，看起來像是foo被timeit裝飾了。在在這個例子中，函數進入和退出時需要計時，這被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。與傳統編程習慣的從上往下執行方式相比較而言，像是在函數執行的流程中橫向地插入了一段邏輯。在特定的業務領域里，能減少大量重復代碼。面向切面編程還有相當多的術語，這里就不多做介紹，感興趣的話可以去找找相關的資料。
這個例子僅用于演示，并沒有考慮foo帶有參數和有返回值的情況，完善它的重任就交給你了 ：）
上面這段代碼看起來似乎已經不能再精簡了，Python于是提供了一個語法糖來降低字符輸入量。
import time
def timeit(func):
def wrapper():
start = time.time()
func()
time.sleep(2)
end = time.time()
print('used:', end - start)
return wrapper
@timeit
def foo():
print('in foo()')
foo()
重點關注第11行的@timeit，在定義上加上這一行與另外寫foo = timeit(foo)完全等價，千萬不要以為@有另外的魔力。除了字符輸入少了一些，還有一個額外的好處：這樣看上去更有裝飾器的感覺。
看到這里其實你也明白了,python 中的裝飾器本質上就是一個函數,這個函數接收其他的函數作為參數,并將其以一個全新的修改后的函數替換它。
4.對帶參數的函數使用裝飾器
如果要包裝的函數有參數，也不麻煩，只要內嵌包裝函數的形參和返回值與原函數相同，裝飾函數返回內嵌包裝函數對象就可以啦
import datetime,time
def out(func):
def inner(*args):
start = datetime.datetime.now()
func(*args)
end = datetime.datetime.now()
print(end-start)
print("out and inner")
return inner
@out
def myfunc(*args):
time.sleep(1)
print("args is{}".format(args))
myfunc("lalalal")
5. 給裝飾器參數
給裝飾器傳參也不難，和上一示例相比在外層多了一層包裝而已
#coding:utf-8
def outermost(*args):
def out(func):
print ("裝飾器參數{}".format(args))
def inner(*args):
print("innet start")
func(*args)
print ("inner end")
return inner
return out
@outermost(666)
def myfun(*args):
print ("試試裝飾器和函數都帶參數的情況,被裝飾的函數參數{}".format(args))
myfun("zhangkun")
6.帶類參數的裝飾器
參數是什么類型其實都不影響的，你看，參數是個類也一樣的
class locker:
def __init__(self):
print("locker.__init__() should be not called")
@staticmethod
def acquire():
print("locker.acquire() static method be called")
@staticmethod
def release():
print("locker.release() static method be called")
def outermost(cls):
def out(func):
def inner():
cls.acquire()
func()
cls.release()
return inner
return out
@outermost(locker)
def myfunc():
print("myfunc called")
myfunc()
7. 對一個函數應用多個裝飾器
一個函數可以擁有多個裝飾器，但是要注意順序
class mylocker:
def __init__(self):
print("mylocker.__init__() called.")
@staticmethod
def acquire():
print("mylocker.acquire() called.")
@staticmethod
def unlock():
print(" mylocker.unlock() called.")
class lockerex(mylocker):
@staticmethod
def acquire():
print("lockerex.acquire() called.")
@staticmethod
def unlock():
print(" lockerex.unlock() called.")
def lockhelper(cls):
def _deco(func):
def __deco2(*args, **kwargs):
print("before %s called." % func.__name__)
cls.acquire()
try:
return func(*args, **kwargs)
finally:
cls.unlock()
return __deco2
return _deco
class example:
@lockhelper(mylocker)
@lockhelper(lockerex)
def myfunc2(self, a, b):
print(" myfunc2() called.")
print(a+b)
a = example()
a.myfunc2(1,2)
8. 作為一個類
雖然裝飾器幾乎總是可以用函數實現,但是在某些情況下,使用用戶自定義的類可能會更好
import time
class DerocatorAsClass:
def __init__(self,funcation):
self.funcation = funcation
def __call__(self, *args, **kwargs):
# 調用函數之前,做點什么
result = self.funcation(*args,**kwargs)
print('3333333333')
# 在調用之后做點什么并且返回結果
return result
@DerocatorAsClass
def foo():
print('in foo()')
foo()
如上例，用類作為裝飾器也是很方便的
以上就是python中的裝飾器該如何使用的詳細內容，更多關于python 裝飾器的使用的資料請關注腳本之家其它相關文章！
您可能感興趣的文章:- 如何正確理解python裝飾器
- Python必備基礎之閉包和裝飾器知識總結
- python 裝飾器的使用與要點
- Python pytest裝飾器總結(實例詳解)
- Python 的lru_cache裝飾器使用簡介
- python裝飾器代碼深入講解
- python 裝飾器重要在哪
- Python 中的函數裝飾器和閉包詳解
- 詳解Python模塊化編程與裝飾器
- python 裝飾器的基本使用
- Python高階函數與裝飾器函數的深入講解
