裝飾器說明

• Python中的裝飾器是一種可以裝飾其它物件的工具。
• 該工具本質上是一個可呼叫的物件（callable），所以裝飾器一般可以由函式、類來實現。
• 裝飾器本身需要接受一個被裝飾的物件作為引數，該引數通常為函式、方法、類等物件。
• 裝飾器需要返回一個物件，該物件可以是 經過處理的原引數物件、一個包裝且類似原引數的物件；或者返回一個不相干內容（通常不建議使用）

相信通過上述一段文字的描述，大家應該更加的迷惑了！所以下面我們就結合程式碼來理解Python中的裝飾器。

裝飾器分類

最簡單的裝飾器

def warp(obj):
    return obj

沒錯！！！這就是最簡單的裝飾器，並且是一個沒有任何用處的裝飾器。但是它確實是一個裝飾器，並且可以用的很好。比如：

@warp    # 等價於 foo = warp(foo)
def foo():    
    print('hello decorator!')

foo()    # => hello decorator!

而上面使用了裝飾器的程式碼，其實我們可以通過其它方式達到相同的效果。具體見下：

def foo():
    print('hello decorator!')

foo = warp(foo)
foo()    # => hello decorator!

So，通過最簡單的程式碼，我們可以發現裝飾器其實就是接受了一個函式（物件），並且返回了一個函式（物件）的函式（可呼叫物件）。

用於修改物件的裝飾器

在理解了裝飾器的含義之後，再來看一個稍微有點作用的裝飾器。程式碼如下：

def warp(obj):
    obj.name = 'python'
    return obj

這個裝飾器在上一個例子的基礎上，只添加了一行程式碼，但是卻有了實際的作用。它的作用就是給被裝飾的物件，新增一個name屬性並且設定值為python。這個裝飾器的使用效果如下：

@warp        # => Bar = warp(Bar)
class Bar(object):
    def __init__(self):
        pass

print(Bar.name)     # => python
 

可以看到實際的使用過程中，warp裝飾器已經成功的給Bar物件添加了name屬性。除了給類物件新增屬性之外，它還可以給函式物件新增屬性。

@warp       # => foo = warp(foo)
def foo():
    pass

print(foo.name)         # => python

用於模擬物件的裝飾器--函式裝飾器

上面例子中的裝飾器，是直接修改了傳入物件；而裝飾器最常用的方式卻是模擬一個傳入物件。即返回一個和原物件相似的物件（即呼叫介面完全一樣的另一個物件），並且該模擬物件是包裝了原物件在內的。具體程式碼如下：

def outer(func):         # 函式裝飾器
    def inner():
        func()

    return inner

上面是一個函式裝飾器，即用來修飾函式的裝飾器。因為它返回了一個模擬func物件的inner物件。而這裡inner物件是一個函式，所以這個裝飾器只能裝飾函式。（因為inner物件只能模擬func這樣的函式物件，不能模擬class物件）

@outer      # foo = outer(foo)
def foo():
    print('hello foo')

foo()    # => hello foo

上述程式碼中最後一行foo()，其實質上是執行的inner()。為了證明這一點，我們可以在inner中列印一條資訊。並檢視下foo的__name__屬性。

def outer(func):         # 函式裝飾器
    def inner():
        print('hello inner')
        func()

    return inner

@outer      # foo = outer(foo)
def foo():
    print('hello foo')

print(foo.__name__)
foo()

上述程式碼執行後的結果如下：

inner
hello inner
hello foo

可以看到首先列印的是 foo.__name__程式碼，注意內容是inner而不是foo（說明其本質上是inner函式）；其次列印的時候，先列印inner函式中的內容，後列印foo函式中的內容。

用於模擬物件的裝飾器--類方法裝飾器

與函式裝飾器類似的還有類方法裝飾器，其作用相同，格式相近。只是些微有些區別，下面就是類方法裝飾器的程式碼。

def outer(obj):         # 類方法裝飾器
    def inner(self):
        print('hello inner')
        obj(self)

    return inner

class Zoo(object):
    def __init__(self):
        pass

    @outer        # => zoo = outer(zoo)
    def zoo(self):
        print('hello zoo')

zoo = Zoo()
print(zoo.zoo.__name__)
zoo.zoo()

可以看到類方法裝飾器和函式裝飾器，唯一的區別就是多了一個預設的self引數；這是因為類方法本身就比函式多這麼一個引數。其執行的結果如下：

inner
hello inner
hello zoo

所以最後一行程式碼zoo.zoo函式執行的其實是inner函式。

用於模擬物件的裝飾器--類裝飾器

裝飾器除了可以裝飾函式、方法之外，還可以裝飾器類物件。具體的程式碼如下：

def outer(clss):         # 類裝飾器
    class Inner(object):
        def __init__(self):
            self.clss = clss()

        def __getattr__(self, attr):
            return getattr(self.clss, attr)

    return Inner


@outer          # Zoo = outer(Zoo)
class Zoo(object):
    def __init__(self):
        pass

    def say(self):
        print('hello world!')

zoo = Zoo()
print(zoo.__class__)    # <class '__main__.outer.<locals>.Inner'>
zoo.say()               # hello world!

通過程式碼可以看出，類裝飾器與函式裝飾器類似。即模擬一個與原引數介面一致的類物件。所以對於模擬類的裝飾器，只能用在其可以模擬的物件之上，並不能互相修飾其它型別的物件。

特殊應用的裝飾器

上面都是比較常規的裝飾器，python中還有另外一些特殊的裝飾器。比如：類靜態屬性裝飾器。比如下面的程式碼：

class Foo(object):
    def __init__(self, height, weigth):
        self.height = height
        self.weigth = weigth

    @property
    def ratio(self):
        return self.height / self.weigth

foo = Foo(176, 120)
print(foo.ratio)    # => 1.4666666666666666

上述程式碼中的@property裝飾器就是一個特殊的裝飾器，它把ratio方法變成了一個屬性。從最後一句呼叫程式碼可以看出，使用的是foo.ratio而不是foo.ratio()。

對於這類裝飾器需要Python的特定屬性和機制的支援才可以實現，不同特性的裝飾器所需機制不同。如上述程式碼中的@property裝飾器就可以使用下面的程式碼來實現。

class Prop(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, instance, owner):
        return self.fget(instance)

具體的使用效果如下：

class Foo(object):
    def __init__(self, height, weigth):
        self.height = height
        self.weigth = weigth

    @Prop
    def ratio(self):
        return self.height / self.weigth

foo = Foo(176, 120)
print(foo.ratio)    # => 1.4666666666666666

可以看到效果和原生的@property裝飾器是一樣的。

類實現的裝飾器

在之前對於裝飾器的說明中，有說道裝飾器是一個callable物件。除了函式可以實現裝飾器之外，還可以通過類來實現。那麼類實現裝飾器的具體程式碼如下：

class Warp(object):
    def __init__(self):
        pass

    def __call__(self, obj):
        obj.name = 'warp'
        return obj

這個類裝飾器實現的功能，也是給傳入的物件新增name屬性，並設定其值為warp。其呼叫效果如下：

@Warp()
def foo():
    pass

print(foo.name)    # => warp

裝飾帶引數/返回值的物件

前面列舉的所有例子，被裝飾的物件都是無引數的。如果你需要裝飾一個帶引數的物件。那麼就需要響應的修改下裝飾器程式碼了。注意：這裡特指那些模擬型別的裝飾器。即函式裝飾器、類方法裝飾器、類裝飾器。

假設我們先有一個帶引數的函式，其內容如下：

def add(x, y):
    return x * y

如果使用原來的函式裝飾器，肯定就會出錯。主要因為這個函式帶引數，並且也有返回值。而原來的函式裝飾器則不能支援，原函式裝飾器如下：

def outer(func):         # 函式裝飾器
    def inner():
        func()

    return inner

可以看到inner模擬的僅僅是一個無引數、無返回值的物件。所以需要進行如下的修改：

def outer(func):         # 函式裝飾器
    def inner(x, y):
        print('hello inner')
        return func(x, y)

    return inner

這樣的函式裝飾器就可以裝飾add函數了。因為inner函式添加了x，y引數，呼叫func物件時也添加了引數，並且返回了func物件的返回值。具體使用效果如下：

@outer
def add(x, y):
    return x * y

print(add(2, 3))    # => 6

上述程式碼雖然可以實現add的裝飾功能，但是如果現在我們在出現一個三個引數的函式需要裝飾，或者一個帶預設值引數的韓式需要裝飾怎麼辦。我們不可能為沒一個不同引數的函式都寫一個相同功能的裝飾器。所以終極的函式裝飾器的寫法如下：

def outer(func):         # 函式裝飾器
    def inner(*args, **kwargs):
        print('hello inner')
        return func(*args, **kwargs)

    return inner

這裡使用了python中動態引數的概念，這樣裝飾器就可以支援任意的組合引數的函數了。

裝飾器帶引數

上面說到的是被修飾的物件帶引數的情況，還有一種情況就是裝飾器本身希望支援帶引數。這種情況類似於函式模組通過帶引數可以更加靈活的道理一樣。通過給裝飾器帶上引數，可以使得裝飾器的功能更加的靈活。程式碼如下：

url_mapping = {}

def route(url):
    def decorator(func):         # 函式裝飾器
        url_mapping[url] = func
        return func
    return decorator

上面是一個URL路由對映的裝飾器，可以給不同的函式繫結不同的路由。如果裝飾器不能帶引數，則無法實現這樣的功能。其使用效果如下：

@route('/home')
def home():
    pass
    
@route('/index')
def index():
    pass
    
print(url_mapping)  # => {'/home': <function home at 0x01DAD810>, '/index': <function index at 0x01DAD7C8>}

裝飾器應用

Python裝飾器的應用比較廣泛，大部分場景的公共處理邏輯都可以使用裝飾器去簡化。（使用上類似於JAVA中的註解）一般比較常見的場景比如：

• 日誌記錄
• 許可權驗證
• 單例模式
• 競爭資源管理