Python裝飾器迪士尼彩樂園搭建高級用法

在Python中，迪士尼彩樂園搭建 需要請搜索【番薯源碼論壇】http://t.cn/EUw2Ui0
客服企娥2947702644 V信17061869203 裝飾器一般用來修飾函數，實現公共功能，達到代碼複用的目的。在函數定義前加上@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 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)
當然了，函數調用盡量使用關鍵字參數是一種極佳實踐，含義清晰，在參數很多的情況下更是如此。