Python裝飾器用法

在Python中，裝飾器通常用來修飾函數，實現公共功能，達到代碼複用的目的。在函數定義前加上@xxxx，而後函數就注入了某些行爲，很神奇！然而，這只是語法糖而已。

場景

假設，有一些工做函數，用來對數據作不一樣的處理：

def work_bar(data): pass def work_foo(data): pass

咱們想在函數調用前/後輸出日誌，怎麼辦？

傻瓜解法

logging.info('begin call work_bar') work_bar(1) logging.info('call work_bar done')

若是有多處代碼調用呢？想一想就怕！

函數包裝

傻瓜解法無非是有太多代碼冗餘，每次函數調用都要寫一遍logging。能夠把這部分冗餘邏輯封裝到一個新函數裏：

def smart_work_bar(data): logging.info('begin call: work_bar') work_bar(data) logging.info('call done: work_bar')

這樣，每次調用smart_work_bar便可：

smart_work_bar(1) # ... smart_work_bar(some_data)

通用閉包

看上去挺完美……然而，當work_foo也有一樣的須要時，還要再實現一遍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

這個函數接收一個函數對象(被代理函數)做爲參數，返回一個代理函數。調用代理函數時，先輸出日誌，而後調用被代理函數，調用完成後再輸出日誌，最後返回調用結果。這樣，不就達到通用化的目的了嗎？——對於任意被代理函數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接收參數work_bar，返回一個代理函數proxy，並賦給smart_work_bar。第4行中，調用smart_work_bar，也就是代理函數proxy，先輸出日誌，而後調用func也就是work_bar，最後再輸出日誌。注意到，代理函數中，func與傳進去的work_bar對象牢牢關聯在一塊兒了，這就是閉包。

再提一下，能夠覆蓋被代理函數名，以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()

看上去好奇怪哦，沒有定義代理函數，算裝飾器嗎？

@eval_now def foo(): return 1 print foo

這段代碼輸出1，也就是對函數進行調用求值。那麼到底有什麼用呢？直接寫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...

兩段代碼要達到的目的是同樣的，可是後者顯然更清晰，很有代碼塊的風範。更重要的是，函數調用在局部名字空間完成初始化，避免臨時變量(如formatter等)污染外部的名字空間(好比全局)。

帶參數裝飾器

定義一個裝飾器，用於記錄慢函數調用：

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行分別在函數調用先後採樣當前時間，第7行計算調用耗時，耗時大於一秒輸出一條警告日誌。

@log_slow_call def sleep_seconds(seconds): time.sleep(seconds) sleep_seconds(0.1) # 沒有日誌輸出 sleep_seconds(2) # 輸出警告日誌

然而，閾值設置老是要視狀況決定，不一樣的函數可能會設置不一樣的值。若是閾值有辦法參數化就行了：

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語法糖老是以被裝飾函數爲參數調用裝飾器，也就是說沒有機會傳遞threshold參數。怎麼辦呢？——用一個閉包封裝threshold參數：

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)調用返回函數decorator，函數擁有閉包變量threshold，值爲0.5。decorator再裝飾sleep_seconds。

採用默認閾值，函數調用仍是不能省略：

@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默認閾值(無調用)；用法B自定義閾值(有調用)。

# 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中，發生的事情是log_slow_call(sleep_seconds)，也就是func參數是非空的，這是直接調decorator進行包裝並返回(閾值是默認的)。

用法B中，先發生的是log_slow_call(threshold=0.5)，func參數爲空，直接返回新的裝飾器decorator，關聯閉包變量threshold，值爲0.5；而後，decorator再裝飾函數sleep_seconds，即decorator(sleep_seconds)。注意到，此時threshold關聯的值是0.5，完成定製化。

你可能注意到了，這裏最好使用關鍵字參數這種調用方式——使用位置參數會很醜陋：

# Case B- @log_slow_call(None, 0.5) def sleep_seconds(seconds): time.sleep(seconds)

固然了，函數調用盡可能使用關鍵字參數是一種極佳實踐，含義清晰，在參數不少的狀況下更是如此。

智能裝飾器

上節介紹的寫法，嵌套層次較多，若是每一個相似的裝飾器都用這種方法實現，仍是比較費勁的(腦子不夠用)，也比較容易出錯。

假設有一個智能裝飾器smart_decorator，修飾裝飾器log_slow_call，即可得到一樣的能力。這樣，log_slow_call定義將變得更清晰，實現起來也更省力啦：

@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如何實現呢？其實也簡單：

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實現了之後，設想就成立了！這時，log_slow_call，就是decorator_proxy(外層)，關聯的閉包變量decorator是本節最開始定義的log_slow_call(爲了不歧義，稱爲real_log_slow_call)。log_slow_call支持如下各類用法：

# Case A @log_slow_call def sleep_seconds(seconds): time.sleep(seconds)

用法A中，執行的是decorator_proxy(sleep_seconds)(外層)，func非空，kwargs爲空；直接執行decorator(func=func, **kwargs)，即real_log_slow_call(sleep_seconds)，結果是關聯默認參數的proxy。

# Case B # Same to Case A @log_slow_call() def sleep_seconds(seconds): time.sleep(seconds)

用法B中，先執行decorator_proxy()，func及kwargs均爲空，返回decorator_proxy對象(內層)；再執行decorator_proxy(sleep_seconds)(內層)；最後執行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中，先執行decorator_proxy(threshold=0.5)，func爲空但kwargs非空，返回decorator_proxy對象(內層)；再執行decorator_proxy(sleep_seconds)(內層)；最後執行decorator(sleep_seconds, **kwargs)，等價於real_log_slow_call(sleep_seconds, threshold=0.5)，閾值實現自定義！

閱讀原文