摘要：一般情況下，我們使用裝飾器提供的語法糖，來簡化上面的寫法像上面的情況，可以動態修改函數或類功能的函數就是裝飾器。本文標題為會打扮的裝飾器本文鏈接為參考資料修飾器的函數式編程中的裝飾器介紹思誠之道裝飾器入門與提高賴明星

我們知道，在 Python 中，我們可以像使用變量一樣使用函數：

函數可以被賦值給其他變量

函數可以被刪除

可以在函數里面再定義函數

函數可以作為參數傳遞給另外一個函數

函數可以作為另一個函數的返回

簡而言之，函數就是一個對象。

為了更好地理解裝飾器，我們先從一個簡單的例子開始，假設有下面的函數：

def hello():
    return "hello world"

現在我們想增強 hello() 函數的功能，希望給返回加上 HTML 標簽，比如 hello world，但是有一個要求，不改變原來 hello() 函數的定義。這里當然有很多種方法，下面給出一種跟本文相關的方法：

def makeitalic(func):
    def wrapped():
        return "" + func() + ""
    return wrapped

在上面的代碼中，我們定義了一個函數 makeitalic，該函數有一個參數 func，它是一個函數；在 makeitalic 函數里面我們又定義了一個內部函數 wrapped，并將該函數作為返回。

現在，我們就可以不改變 hello() 函數的定義，給返回加上 HTML 標簽了：

>>> hello = makeitalic(hello)  # 將 hello 函數傳給 makeitalic
>>> hello()
"hello world"

在上面，我們將 hello 函數傳給 makeitalic，再將返回賦給 hello，此時調用 hello() 就得到了我們想要的結果。

不過要注意的是，由于我們將 makeitalic 的返回賦給了 hello，此時 hello() 函數仍然存在，但是它的函數名不再是 hello 了，而是 wrapped，正是 makeitalic 返回函數的名稱，可以驗證一下：

>>> hello.__name__
"wrapped"

對于這個小瑕疵，后文將會給出解決方法。

現在，我們梳理一下上面的例子，為了增強原函數 hello 的功能，我們定義了一個函數，它接收原函數作為參數，并返回一個新的函數，完整的代碼如下：

def makeitalic(func):
    def wrapped():
        return "" + func() + ""
    return wrapped

def hello():
    return "hello world"

hello = makeitalic(hello)

事實上，makeitalic 就是一個裝飾器（decorator），它『裝飾』了函數 hello，并返回一個函數，將其賦給 hello。

一般情況下，我們使用裝飾器提供的 @ 語法糖（Syntactic Sugar），來簡化上面的寫法：

def makeitalic(func):
    def wrapped():
        return "" + func() + ""
    return wrapped

@makeitalic
def hello():
    return "hello world"

像上面的情況，可以動態修改函數（或類）功能的函數就是裝飾器。本質上，它是一個高階函數，以被裝飾的函數（比如上面的 hello）為參數，并返回一個包裝后的函數（比如上面的 wrapped）給被裝飾函數（hello）。

裝飾器的一般使用形式如下：

@decorator
def func():
    pass

等價于下面的形式：

def func():
    pass
func = decorator(func)

裝飾器可以定義多個，離函數定義最近的裝飾器先被調用，比如：

@decorator_one
@decorator_two
def func():
    pass

等價于：

def func():
    pass

func = decorator_one(decorator_two(func))

裝飾器還可以帶參數，比如：

@decorator(arg1, arg2)
def func():
    pass

等價于：

def func():
    pass

func = decorator(arg1, arg2)(func)

下面我們再看一些具體的例子，以加深對它的理解。

前面的例子中，被裝飾的函數 hello() 是沒有帶參數的，我們看看被裝飾函數帶參數的情況。對前面例子中的 hello() 函數進行改寫，使其帶參數，如下：

def makeitalic(func):
    def wrapped(*args, **kwargs):
        ret = func(*args, **kwargs)
        return "" + ret + ""
    return wrapped

@makeitalic
def hello(name):
    return "hello %s" % name
    
@makeitalic
def hello2(name1, name2):
    return "hello %s, %s" % (name1, name2)

由于函數 hello 帶參數，因此內嵌包裝函數 wrapped 也做了一點改變：

內嵌包裝函數的參數傳給了 func，即被裝飾函數，也就是說內嵌包裝函數的參數跟被裝飾函數的參數對應，這里使用了 (*args, **kwargs)，是為了適應可變參數。

看看使用：

>>> hello("python")
"hello python"
>>> hello2("python", "java")
"hello python, java"

上面的例子，我們增強了函數 hello 的功能，給它的返回加上了標簽 ...，現在，我們想改用標簽 ... 或

...

def wrap_in_tag(tag):
    def decorator(func):
        def wrapped(*args, **kwargs):
            ret = func(*args, **kwargs)
            return "<" + tag + ">" + ret + ""
        return wrapped

    return decorator

現在，我們可以根據需要生成想要的裝飾器了：

makebold = wrap_in_tag("b")  # 根據 "b" 返回 makebold 生成器

@makebold
def hello(name):
    return "hello %s" % name
    
>>> hello("world")
"hello world"

上面的形式也可以寫得更加簡潔：

@wrap_in_tag("b")
def hello(name):
    return "hello %s" % name

這就是帶參數的裝飾器，其實就是在裝飾器外面多了一層包裝，根據不同的參數返回不同的裝飾器。

現在，讓我們來看看多個裝飾器的例子，為了簡單起見，下面的例子就不使用帶參數的裝飾器。

def makebold(func):
    def wrapped():
        return "" + func() + ""

    return wrapped

def makeitalic(func):
    def wrapped():
        return "" + func() + ""

    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

上面定義了兩個裝飾器，對 hello 進行裝飾，上面的最后幾行代碼相當于：

def hello():
    return "hello world"

hello = makebold(makeitalic(hello))

調用函數 hello：

>>> hello()
"hello world"

前面的裝飾器都是一個函數，其實也可以基于類定義裝飾器，看下面的例子：

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

    def __call__(self, *args, **kwargs):
        return "" + self.func(*args, **kwargs) + ""

@Bold
def hello(name):
    return "hello %s" % name

>>> hello("world")
"hello world"

可以看到，類 Bold 有兩個方法：

__init__()：它接收一個函數作為參數，也就是被裝飾的函數

__call__()：讓類對象可調用，就像函數調用一樣，在調用被裝飾函數時被調用

還可以讓類裝飾器帶參數：

class Tag(object):
    def __init__(self, tag):
        self.tag = tag

    def __call__(self, func):
        def wrapped(*args, **kwargs):
            return "<{tag}>{res}".format(
                res=func(*args, **kwargs), tag=self.tag
            )
        return wrapped

@Tag("b")
def hello(name):
    return "hello %s" % name

需要注意的是，如果類裝飾器有參數，則 __init__ 接收參數，而 __call__ 接收 func。

前面提到，使用裝飾器有一個瑕疵，就是被裝飾的函數，它的函數名稱已經不是原來的名稱了，回到最開始的例子：

def makeitalic(func):
    def wrapped():
        return "" + func() + ""
    return wrapped

@makeitalic
def hello():
    return "hello world"

函數 hello 被 makeitalic 裝飾后，它的函數名稱已經改變了：

>>> hello.__name__
"wrapped"

為了消除這樣的副作用，Python 中的 functool 包提供了一個 wraps 的裝飾器：

from functools import wraps

def makeitalic(func):
    @wraps(func)       # 加上 wraps 裝飾器
    def wrapped():
        return "" + func() + ""
    return wrapped

@makeitalic
def hello():
    return "hello world"

>>> hello.__name__
"hello"

本質上，裝飾器就是一個返回函數的高階函數。

裝飾器可以動態地修改一個類或函數的功能，通過在原有的類或者函數上包裹一層修飾類或修飾函數實現。

事實上，裝飾器就是閉包的一種應用，但它比較特別，接收被裝飾函數為參數，并返回一個函數，賦給被裝飾函數，閉包則沒這種限制。

本文由 funhacks 發表于個人博客，采用 Creative Commons BY-NC-ND 4.0（自由轉載-保持署名-非商用-禁止演繹）協議發布。
非商業轉載請注明作者及出處。商業轉載請聯系作者本人。
本文標題為: Python: 會打扮的裝飾器
本文鏈接為: https://funhacks.net/2016/11/...

Python修飾器的函數式編程 - coolshell

How can I make a chain of function decorators in Python? - Stack Overflow

Python中的裝飾器介紹 – 思誠之道

python裝飾器入門與提高 | 賴明星