Python中裝飾器高級用法詳解
在Python中，裝飾器一般用來修飾函數(shù)，實現(xiàn)公共功能，達到代碼復用的目的。在函數(shù)定義前加上@xxxx，然后函數(shù)就注入了某些行為，很神奇！然而，這只是語法糖而已。
場景
假設，有一些工作函數(shù)，用來對數(shù)據(jù)做不同的處理：
def work_bar(data): pass def work_foo(data): pass
我們想在函數(shù)調(diào)用前/后輸出日志，怎么辦？
傻瓜解法
logging.info('begin call work_bar')
work_bar(1)
logging.info('call work_bar done')
如果有多處代碼調(diào)用呢？想想就怕！
函數(shù)包裝
傻瓜解法無非是有太多代碼冗余，每次函數(shù)調(diào)用都要寫一遍logging?？梢园堰@部分冗余邏輯封裝到一個新函數(shù)里：
def smart_work_bar(data):
logging.info('begin call: work_bar')
work_bar(data)
logging.info('call doen: work_bar')
這樣，每次調(diào)用smart_work_bar即可：
smart_work_bar(1) # ... smart_work_bar(some_data)
通用閉包
看上去挺完美……然而，當work_foo也有同樣的需要時，還要再實現(xiàn)一遍smart_work_foo嗎？這樣顯然不科學呀！
別急，我們可以用閉包：
def log_call(func):
def proxy(*args, **kwargs):
logging.info('begin call: {name}'.format(name=func.func_name))
result = func(*args, **kwargs)
logging.info('call done: {name}'.format(name=func.func_name))
return result
return proxy
這個函數(shù)接收一個函數(shù)對象(被代理函數(shù))作為參數(shù)，返回一個代理函數(shù)。調(diào)用代理函數(shù)時，先輸出日志，然后調(diào)用被代理函數(shù)，調(diào)用完成后再輸出日志，最后返回調(diào)用結果。這樣，不就達到通用化的目的了嗎？——對于任意被代理函數(shù)func，log_call均可輕松應對。
smart_work_bar = log_call(work_bar) smart_work_foo = log_call(work_foo) smart_work_bar(1) smart_work_foo(1) # ... smart_work_bar(some_data) smart_work_foo(some_data)
第1行中，log_call接收參數(shù)work_bar，返回一個代理函數(shù)proxy，并賦給smart_work_bar。第4行中，調(diào)用smart_work_bar，也就是代理函數(shù)proxy，先輸出日志，然后調(diào)用func也就是work_bar，最后再輸出日志。注意到，代理函數(shù)中，func與傳進去的work_bar對象緊緊關聯(lián)在一起了，這就是閉包。
再提一下，可以覆蓋被代理函數(shù)名，以smart_為前綴取新名字還是顯得有些累贅：
work_bar = log_call(work_bar) work_foo = log_call(work_foo) work_bar(1) work_foo(1)
語法糖
先來看看以下代碼：
def work_bar(data): pass work_bar = log_call(work_bar) def work_foo(data): pass work_foo = log_call(work_foo)
雖然代碼沒有什么冗余了，但是看是去還是不夠直觀。這時候，語法糖來了~~~
@log_call def work_bar(data): pass
因此，注意一點(劃重點啦)，這里@log_call的作用只是：告訴Python編譯器插入代碼work_bar = log_call(work_bar)。
求值裝飾器
先來猜猜裝飾器eval_now有什么作用？
def eval_now(func): return func()
看上去好奇怪哦，沒有定義代理函數(shù)，算裝飾器嗎？
@eval_now def foo(): return 1 print foo
這段代碼輸出1，也就是對函數(shù)進行調(diào)用求值。那么到底有什么用呢？直接寫foo = 1不行么？在這個簡單的例子，這么寫當然可以啦。來看一個更復雜的例子——初始化一個日志對象：
# some other code before... # log format formatter = logging.Formatter( '[%(asctime)s] %(process)5d %(levelname) 8s - %(message)s', '%Y-%m-%d %H:%M:%S', ) # stdout handler stdout_handler = logging.StreamHandler(sys.stdout) stdout_handler.setFormatter(formatter) stdout_handler.setLevel(logging.DEBUG) # stderr handler stderr_handler = logging.StreamHandler(sys.stderr) stderr_handler.setFormatter(formatter) stderr_handler.setLevel(logging.ERROR) # logger object logger = logging.Logger(__name__) logger.setLevel(logging.DEBUG) logger.addHandler(stdout_handler) logger.addHandler(stderr_handler) # again some other code after...
用eval_now的方式：
# some other code before...
@eval_now
def logger():
# log format
formatter = logging.Formatter(
'[%(asctime)s] %(process)5d %(levelname) 8s - %(message)s',
'%Y-%m-%d %H:%M:%S',
)
# stdout handler
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setFormatter(formatter)
stdout_handler.setLevel(logging.DEBUG)
# stderr handler
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setFormatter(formatter)
stderr_handler.setLevel(logging.ERROR)
# logger object
logger = logging.Logger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(stdout_handler)
logger.addHandler(stderr_handler)
return logger
# again some other code after...
兩段代碼要達到的目的是一樣的，但是后者顯然更清晰，頗有代碼塊的風范。更重要的是，函數(shù)調(diào)用在局部名字空間完成初始化，避免臨時變量(如formatter等)污染外部的名字空間(比如全局)。
帶參數(shù)裝飾器
定義一個裝飾器，用于記錄慢函數(shù)調(diào)用：
def log_slow_call(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > 1:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
第3、5行分別在函數(shù)調(diào)用前后采樣當前時間，第7行計算調(diào)用耗時，耗時大于一秒輸出一條警告日志。
@log_slow_call def sleep_seconds(seconds): time.sleep(seconds) sleep_seconds(0.1) # 沒有日志輸出 sleep_seconds(2) # 輸出警告日志
然而，閾值設置總是要視情況決定，不同的函數(shù)可能會設置不同的值。如果閾值有辦法參數(shù)化就好了：
def log_slow_call(func, threshold=1):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
然而，@xxxx語法糖總是以被裝飾函數(shù)為參數(shù)調(diào)用裝飾器，也就是說沒有機會傳遞threshold參數(shù)。怎么辦呢？——用一個閉包封裝threshold參數(shù)：
def log_slow_call(threshold=1):
def decorator(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
return decorator
@log_slow_call(threshold=0.5)
def sleep_seconds(seconds):
time.sleep(seconds)
這樣，log_slow_call(threshold=0.5)調(diào)用返回函數(shù)decorator，函數(shù)擁有閉包變量threshold，值為0.5。decorator再裝飾sleep_seconds。
采用默認閾值，函數(shù)調(diào)用還是不能省略：
@log_slow_call() def sleep_seconds(seconds): time.sleep(seconds)
處女座可能會對第一行這對括號感到不爽，那么可以這樣改進：
def log_slow_call(func=None, threshold=1):
def decorator(func):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
if func is None:
return decorator
else:
return decorator(func)
這種寫法兼容兩種不同的用法，用法A默認閾值(無調(diào)用)；用法B自定義閾值(有調(diào)用)。
# Case A @log_slow_call def sleep_seconds(seconds): time.sleep(seconds) # Case B @log_slow_call(threshold=0.5) def sleep_seconds(seconds): time.sleep(seconds)
用法A中，發(fā)生的事情是log_slow_call(sleep_seconds)，也就是func參數(shù)是非空的，這是直接調(diào)decorator進行包裝并返回(閾值是默認的)。
用法B中，先發(fā)生的是log_slow_call(threshold=0.5)，func參數(shù)為空，直接返回新的裝飾器decorator，關聯(lián)閉包變量threshold，值為0.5；然后，decorator再裝飾函數(shù)sleep_seconds，即decorator(sleep_seconds)。注意到，此時threshold關聯(lián)的值是0.5，完成定制化。
你可能注意到了，這里最好使用關鍵字參數(shù)這種調(diào)用方式——使用位置參數(shù)會很丑陋：
# Case B- @log_slow_call(None, 0.5) def sleep_seconds(seconds): time.sleep(seconds)
當然了，函數(shù)調(diào)用盡量使用關鍵字參數(shù)是一種極佳實踐，含義清晰，在參數(shù)很多的情況下更是如此。
智能裝飾器
上節(jié)介紹的寫法，嵌套層次較多，如果每個類似的裝飾器都用這種方法實現(xiàn)，還是比較費勁的(腦子不夠用)，也比較容易出錯。
假設有一個智能裝飾器smart_decorator，修飾裝飾器log_slow_call，便可獲得同樣的能力。這樣，log_slow_call定義將變得更清晰，實現(xiàn)起來也更省力啦：
@smart_decorator
def log_slow_call(func, threshold=1):
def proxy(*args, **kwargs):
start_ts = time.time()
result = func(*args, **kwargs)
end_ts = time.time()
seconds = start_ts - end_ts
if seconds > threshold:
logging.warn('slow call: {name} in {seconds}s'.format(
name=func.func_name,
seconds=seconds,
))
return result
return proxy
腦洞開完，smart_decorator如何實現(xiàn)呢？其實也簡單：
def smart_decorator(decorator):
def decorator_proxy(func=None, **kwargs):
if func is not None:
return decorator(func=func, **kwargs)
def decorator_proxy(func):
return decorator(func=func, **kwargs)
return decorator_proxy
return decorator_proxy
smart_decorator實現(xiàn)了以后，設想就成立了！這時，log_slow_call，就是decorator_proxy(外層)，關聯(lián)的閉包變量decorator是本節(jié)最開始定義的log_slow_call(為了避免歧義，稱為real_log_slow_call)。log_slow_call支持以下各種用法：
# Case A @log_slow_call def sleep_seconds(seconds): time.sleep(seconds)
用法A中，執(zhí)行的是decorator_proxy(sleep_seconds)(外層)，func非空，kwargs為空；直接執(zhí)行decorator(func=func, **kwargs)，即real_log_slow_call(sleep_seconds)，結果是關聯(lián)默認參數(shù)的proxy。
# Case B # Same to Case A @log_slow_call() def sleep_seconds(seconds): time.sleep(seconds)
用法B中，先執(zhí)行decorator_proxy()，func及kwargs均為空，返回decorator_proxy對象(內(nèi)層)；再執(zhí)行decorator_proxy(sleep_seconds)(內(nèi)層)；最后執(zhí)行decorator(func, **kwargs)，等價于real_log_slow_call(sleep_seconds)，效果與用法A一致。
# Case C @log_slow_call(threshold=0.5) def sleep_seconds(seconds): time.sleep(seconds)
用法C中，先執(zhí)行decorator_proxy(threshold=0.5)，func為空但kwargs非空，返回decorator_proxy對象(內(nèi)層)；再執(zhí)行decorator_proxy(sleep_seconds)(內(nèi)層)；最后執(zhí)行decorator(sleep_seconds, **kwargs)，等價于real_log_slow_call(sleep_seconds, threshold=0.5)，閾值實現(xiàn)自定義！
相關文章
下面小編就為大家?guī)硪黄猵ython生成詞云的實現(xiàn)方法(推薦)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-06-06
這篇文章主要介紹了pandas獲取csv指定行，列的操作方法，本文簡單易懂，非常不錯，具有一定的參考借鑒價值,需要的朋友可以參考下2019-07-07
制作視頻的時候，多少需要一些搞怪的聲音？或者奇怪的聲音？音樂等等。一個個下載多慢，我們今天就用python實現(xiàn)批量下載！需要的可以參考一下2022-02-02
異常是一個事件，該事件會在程序執(zhí)行過程中發(fā)生，影響了程序的正常執(zhí)行。 運算符重載，意味著在某個類的方法中攔截內(nèi)置的操作，當類的實例出現(xiàn)在內(nèi)置操作中，Python會調(diào)用你的方法，并且方法的返回值會作為相應操作的結果。本文主要介紹了python的高級異常和運算符重載2021-06-06
python lambda表達式在sort函數(shù)中的使用詳解
這篇文章主要介紹了python lambda表達式在sort函數(shù)中的使用詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-08-08
這篇文章主要介紹了模型訓練時GPU利用率太低的原因及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-02-02
python爬蟲數(shù)據(jù)保存到mongoDB的實例方法
在本篇文章里小編給大家整理的是一篇關于python爬蟲數(shù)據(jù)保存到mongoDB的實例方法，有需要的朋友們可以參考下。2020-07-07
這篇文章主要介紹了python RabbitMQ 使用詳細介紹(小結)，詳細的介紹了RabbitMQ的概念以及使用，對學習RabbitMQ有一定的幫助，非常具有實用價值，需要的朋友可以參考下2018-11-11
在python中枚舉是一種類（Enum,IntEnum），存放在enum模塊中。枚舉類型可以給一組標簽賦予一組特定的值，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-10-10
Python算法之求n個節(jié)點不同二叉樹個數(shù)
本文先向大家分享了建立二叉樹的簡單代碼，其次介紹了Python計算n個節(jié)點不同二叉樹個數(shù)的問題及實現(xiàn)代碼示例，具有一定參考價值，需要的朋友可以了解下。2017-10-10