轉自Python之禪

講 Python 裝飾器前，我想先舉個例子，雖有點污，但跟裝飾器這個話題很貼切。

每個人都有的內褲主要功能是用來遮羞，但是到了冬天它沒法為我們防風御寒，咋辦？我們想到的一個辦法就是把內褲改造一下，讓它變得更厚更長，這樣一來，它不僅有遮羞功能，還能提供保暖，不過有個問題，這個內褲被我們改造成了長褲后，雖然還有遮羞功能，但本質上它不再是一條真正的內褲了。于是聰明的人們發(fā)明長褲，在不影響內褲的前提下，直接把長褲套在了內褲外面，這樣內褲還是內褲，有了長褲后寶寶再也不冷了。裝飾器就像我們這里說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。

講裝飾器前，還要先明白一件事，Python中的函數(shù)可以像普通變量一樣當做參數(shù)傳遞給另外一個函數(shù)：

def foo():
    print('foolish')

def bar(func):
    func()

bar(foo)
# foolish

回到主題，裝飾器本質上是一個Python函數(shù)或類，他可以讓其他函數(shù)或類在不需要做任何代碼修改的前提下增加額外功能，裝飾器的返回值也是一個函數(shù)/類對象。裝飾器常用于有切面需求的場景，如：插入日志、性能測試、事務處理、緩存、權限校驗等場景，裝飾器是解決這類問題的絕佳設計。有了裝飾器，我們就可以抽離出大量與函數(shù)功能本身無關的雷同代碼到裝飾器中并繼續(xù)重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外功能。
先看一個簡單的例子，雖然實際代碼可能復雜的多：

def foo():
    print('i am foo')

現(xiàn)在有一個新的需求，希望可以記錄下函數(shù)的執(zhí)行日志，于是在代碼中添加日志代碼：

import logging
def foo():
    print('i am foo')
    logging.info('foo is running')

倘若函數(shù)bar()、bar2()也有類似的需求，該怎么做呢？再寫一個loging.info()在bar函數(shù)里？這樣就造成大量雷同的代碼，為了減少重復代碼，我們可以定義一個新函數(shù):專門處理日志，日志處理完之后在執(zhí)行真正的業(yè)務代碼。

def use_logging(func):
    logging.warn("%s is running" % func.__name__)
    func()

def foo():
    print('i am foo')

use_logging(foo)

這樣做邏輯是沒有問題的，功能是實現(xiàn)了，但是我們調用的時候不再是調用真正的業(yè)務邏輯foo函數(shù)，而是換成了use_logging函數(shù)（跟閉包很類似），還有沒有更好
的方法呢？當然，那就是裝飾器！

1、簡單裝飾器

def use_logging(func):
    def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()   # 把 foo 當做參數(shù)傳遞進來時，執(zhí)行func()就相當于執(zhí)行foo()
    return wrapper          ### 閉包

def foo():
    print('i am foo')

foo = use_logging(foo)  # 因為裝飾器 use_logging(foo) 返回的時函數(shù)對象 wrapper，這條語句相當于  foo = wrapper
foo()                   # 執(zhí)行foo()就相當于執(zhí)行 wrapper()

use_logging就是一個裝飾器，他是一個普通的函數(shù)，他把執(zhí)行真正業(yè)務邏輯的函數(shù)func包裹在其中，看起來foo被use_logging裝飾了一樣，use_logging返回的也是一個函數(shù)，這個函數(shù)的名字叫wrapper。在這個例子中，函數(shù)進入和退出時，被稱為一個橫切面，這種編程方式被稱為面向切面的編程。

2、@語法糖

@符號是裝飾器的語法糖，他放在函數(shù)定義的地方，這樣就可以省略最后一步再次賦值的操作。

def use_logging(func):

    def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()
    return wrapper

@use_logging
def foo():
    print("i am foo")

foo()

如上所示，有了@，我們就可以省去f00=use_logging(foo)這一句了，直接調用foo()即可得到想要的結果。而且foo函數(shù)不需要任何修改，只需要在定義的地方加上裝飾器，調用的時候還是和以前一樣，如果有其他類似的函數(shù)，可以繼續(xù)調用裝飾器來裝飾函數(shù)，而不用重復修改函數(shù)或增加新的封裝。這樣就提高了程序的可重復利用性，并增加了程序的可讀性。
裝飾器在Python中使用如此方便都要歸功于Python的函數(shù)能像普通對象一樣作為參數(shù)傳遞給其他函數(shù)，可以被賦值給其他變量，可以作為返回值，可以被定義在另外一個函數(shù)內。

3、參數(shù)傳遞：args、*kwargs

當業(yè)務邏輯函數(shù)foo需要傳遞參數(shù)怎么辦呢？如：

def foo(name):
    print("i am %s" % name)

我們可以在定義wrapper函數(shù)的時候指定參數(shù)：

def use_logging(func):
    def wrapper(name):
        logging.warn("%s is running" % func.__name__)
        return func(name)
    return wrapper

這樣foo函數(shù)定義的參數(shù)就可以定義在wrapper函數(shù)中。當我們foo函數(shù)需要接受多個參數(shù)而又不能確定個數(shù)時，可以使用*args來代替：

def use_logging(func):
    def wrapper(*args):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper

這樣，不管foo定義了多少個函數(shù)，我們都可以完整的傳遞到foo中去，不會影響業(yè)務邏輯了。而對于關鍵字參數(shù)，則可以使用**kwargs，如：

def foo(name, age=None, height=None):
    print("I am %s, age %s, height %s" % (name, age, height))

這時可以把wrapper函數(shù)指定關鍵字函數(shù)：

def wrapper(*args, **kwargs):
        # args是一個數(shù)組，kwargs一個字典
        logging.warn("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

4、帶參數(shù)的裝飾器

裝飾器還有更大的靈活性，例如帶參數(shù)的裝飾器。在上面的裝飾器調用中，該裝飾器唯一接收的參數(shù)就是執(zhí)行業(yè)務的函數(shù)foo。裝飾器的語法允許我們在調用時，提供其他參數(shù)，比如@decorator(a)。這樣，就為裝飾器的編寫和使用提供了更大的靈活性。比如，我們可以在裝飾器中指定日志等級，因為不同函數(shù)可能需要的日志等級是不一樣的。

def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warn("%s is running" % func.__name__)
            elif level == "info":
                logging.info("%s is running" % func.__name__)
            return func(*args)
        return wrapper

    return decorator

@use_logging(level="warn")
def foo(name='foo'):
    print("i am %s" % name)

foo()

上面的use_logging是允許帶參數(shù)的裝飾器。它實際上是對原有裝飾器的一個函數(shù)封裝，并返回一個裝飾器。我們可以將它理解為一個含有參數(shù)的閉包。當我們使用@use_logging(level='warn')調用的時候，Python能發(fā)現(xiàn)這一層的封裝，并把參數(shù)傳遞到裝飾器的環(huán)境中。
@use_logging(level='warn')等價于@decorator。

5、類裝飾器

裝飾器不僅可以是函數(shù)，還可以是類。相比函數(shù)裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優(yōu)點。使用類裝飾器主要依靠類的__call__方法，當使用@形式將裝飾器附加到函數(shù)上時，就會調用此方法。

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print ('class decorator runing')
        self._func()
        print ('class decorator ending')

@Foo
def bar():
    print ('bar')

bar()

6、functools.wraps

使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數(shù)的元信息不見了，比如函數(shù)的docstring、__name__、參數(shù)列表，先看例子：

# 裝飾器
def logged(func):
    def with_logging(*args, **kwargs):
        print func.__name__      # 輸出 'with_logging'
        print func.__doc__       # 輸出 None
        return func(*args, **kwargs)
    return with_logging

# 函數(shù)
@logged
def f(x):
   """does some math"""
   return x + x * x

logged(f)

不難發(fā)現(xiàn)，函數(shù)f被with_logging取代了，他的docstring、__name__自然就變成了with_logging函數(shù)的信息了。好在我們有functools.wraps,wraps本身也是一個裝飾器，他能把原函數(shù)的元信息拷貝到裝飾器里面的func函數(shù)中，使得裝飾器里面的func函數(shù)也和原函數(shù)f一樣的元信息了。

from functools import wraps
def logged(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print func.__name__      # 輸出 'f'
        print func.__doc__       # 輸出 'does some math'
        return func(*args, **kwargs)
    return with_logging

@logged
def f(x):
   """does some math"""
   return x + x * x

7、裝飾器順序

一個函數(shù)可以同時定義多個裝飾器，如：

@a
@b
@c
def f ():
    pass

他的順序是從里到外，最先調用最里層的裝飾器，最后調用最外層的裝飾器，它等效于：

f = a(b(c(f)))