在Python中，裝飾器一般用來修飾函式，實現公共功能，達到程式碼複用的目的。在函式定義前加上@xxxx，然後函式就注入了某些行為，很神奇！然而，這只是語法糖而已。
原文地址：python-book.readthedocs.io
微信公眾號：小菜學程式設計 (coding-fan)
場景
假設，有一些工作函式，用來對資料做不同的處理：
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 doen: 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)，閾值實現自定義！
訂閱更新，獲取更多學習資料，請關注我們的 微信公眾號 ：