Python: 會打扮的裝飾器

發表於2016-11-26

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

函式可以被賦值給其他變數
函式可以被刪除
可以在函式裡面再定義函式
函式可以作為引數傳遞給另外一個函式
函式可以作為另一個函式的返回

簡而言之，函式就是一個物件。

對一個簡單的函式進行裝飾

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

def hello():
    return 'hello world'

1 2	def hello(): return 'hello world'

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

def makeitalic(func):
    def wrapped():
        return "<i>" + func() + "</i>"
    return wrapped

def makeitalic(func):

def wrapped():

return "" + func() + ""

return wrapped

在上面的程式碼中，我們定義了一個函式 makeitalic，該函式有一個引數 func，它是一個函式；在 makeitalic 函式裡面我們又定義了一個內部函式 wrapped，並將該函式作為返回。

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

>>> hello = makeitalic(hello)  # 將 hello 函式傳給 makeitalic
>>> hello()
'<i>hello world</i>'

>>> hello = makeitalic(hello) # 將 hello 函式傳給 makeitalic

>>> hello()

'hello world'

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

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

>>> hello.__name__
'wrapped'

1 2	>>> hello.__name__ 'wrapped'

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

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

def makeitalic(func):
    def wrapped():
        return "<i>" + func() + "</i>"
    return wrapped

def hello():
    return 'hello world'

hello = makeitalic(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 "<i>" + func() + "</i>"
    return wrapped

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

def makeitalic(func):

def wrapped():

return "" + func() + ""

return wrapped

@makeitalic

def hello():

return 'hello world'

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

裝飾器的使用形式

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

@decorator
def func():
    pass

@decorator

def func():

pass

等價於下面的形式：

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

def func():

pass

func = decorator(func)

裝飾器可以定義多個，離函式定義最近的裝飾器先被呼叫，比如：

@decorator_one
@decorator_two
def func():
    pass

@decorator_one

@decorator_two

def func():

pass

等價於：

def func():
    pass

func = decorator_one(decorator_two(func))

def func():

pass

func = decorator_one(decorator_two(func))

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

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

@decorator(arg1, arg2)

def func():

pass

等價於：

def func():
    pass

func = decorator(arg1, arg2)(func)

def func():

pass

func = decorator(arg1, arg2)(func)

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

對帶引數的函式進行裝飾

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

def makeitalic(func):
    def wrapped(*args, **kwargs):
        ret = func(*args, **kwargs)
        return '<i>' + ret + '</i>'
    return wrapped

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

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')
'<i>hello python</i>'
>>> hello2('python', 'java')
'<i>hello python, java</i>'

>>> hello('python')

'hello python'

>>> hello2('python', 'java')

'hello python, java'

帶引數的裝飾器

上面的例子，我們增強了函式 hello 的功能，給它的返回加上了標籤 …，現在，我們想改用標籤 … 或 …。是不是要像前面一樣，再定義一個類似 makeitalic 的裝飾器呢？其實，我們可以定義一個函式，將標籤作為引數，返回一個裝飾器，比如：

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

    return decorator

def wrap_in_tag(tag):

def decorator(func):

def wrapped(*args, **kwargs):

ret = func(*args, **kwargs)

return '<' + tag + '>' + ret + '</' + tag + '>'

return wrapped

return decorator

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

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

@makebold
def hello(name):
    return 'hello %s' % name
    
>>> hello('world')
'<b>hello world</b>'

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

@wrap_in_tag('b')

def hello(name):

return 'hello %s' % name

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

多個裝飾器

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

def makebold(func):
    def wrapped():
        return '<b>' + func() + '</b>'

    return wrapped

def makeitalic(func):
    def wrapped():
        return '<i>' + func() + '</i>'

    return wrapped

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

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))

def hello():

return 'hello world'

hello = makebold(makeitalic(hello))

呼叫函式 hello：

>>> hello()
'<b><i>hello world</i></b>'

1 2	>>> hello() '<b><i>hello world</i></b>'

基於類的裝飾器

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

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

    def __call__(self, *args, **kwargs):
        return '<b>' + self.func(*args, **kwargs) + '</b>'

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

>>> hello('world')
'<b>hello world</b>'

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}</{tag}>".format(
                res=func(*args, **kwargs), tag=self.tag
            )
        return wrapped

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

class Tag(object):

def __init__(self, tag):

self.tag = tag

def __call__(self, func):

def wrapped(*args, **kwargs):

return "<{tag}>{res}</{tag}>".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 "<i>" + func() + "</i>"
    return wrapped

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

def makeitalic(func):

def wrapped():

return "" + func() + ""

return wrapped

@makeitalic

def hello():

return 'hello world'

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

>>> hello.__name__
'wrapped'

1 2	>>> hello.__name__ 'wrapped'

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

from functools import wraps

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

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

>>> hello.__name__
'hello'

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'

<span style="font-family: 'Microsoft YaHei', 宋體, 'Helvetica Neue', Helvetica, Arial, sans-serif;font-size: 28px;font-style: normal;font-weight: normal;background-color: #ffffff">小結</span>

1	<span style="font-family: 'Microsoft YaHei', 宋體, 'Helvetica Neue', Helvetica, Arial, sans-serif;font-size: 28px;font-style: normal;font-weight: normal;background-color: #ffffff">小結</span>

本質上，裝飾器就是一個返回函式的高階函式。
裝飾器可以動態地修改一個類或函式的功能，通過在原有的類或者函式上包裹一層修飾類或修飾函式實現。
事實上，裝飾器就是閉包的一種應用，但它比較特別，接收被裝飾函式為引數，並返回一個函式，賦給被裝飾函式，閉包則沒這種限制。

參考資料

Python 裝飾器你也會用
2019-03-15
Python
python裝飾器2：類裝飾器
2019-01-01
Python
python的裝飾器
2018-08-18
Python
Python 裝飾器裝飾類中的方法
2017-04-17
Python
Python裝飾器探究——裝飾器引數
2016-12-19
Python
Python 裝飾器
2019-06-24
Python
Python裝飾器
2021-02-15
Python
裝飾器 python
2018-01-06
Python
Python中的裝飾器
2022-03-26
Python
Python 裝飾器的理解
2016-07-06
Python
Python裝飾器模式
2022-05-13
Python模式
1.5.3 Python裝飾器
2019-01-19
Python
Python 裝飾器（一）
2018-09-27
Python
Python 裝飾器原理
2023-02-06
Python
python中裝飾器的原理
2018-11-02
Python
Python裝飾器的前世今生
2018-05-28
Python
詳解Python的裝飾器
2016-10-31
Python
理解python中的裝飾器
2015-12-14
Python
草根學Python（十六）裝飾器（逐步演化成裝飾器）
2018-01-11
Python
python 之裝飾器（decorator）
2019-12-17
Python
Python深入05 裝飾器
2019-11-29
Python
Python裝飾器詳解
2020-12-02
Python
【Python】淺談裝飾器
2017-05-01
Python
初識Python裝飾器
2017-06-20
Python
python裝飾器介紹
2017-08-07
Python
淺談Python裝飾器
2014-03-30
Python
Python 工匠：使用裝飾器的技巧
2019-05-11
Python
python類裝飾器的使用注意
2021-09-11
Python
python幾種裝飾器的用法
2018-10-16
Python
Python裝飾器的另類用法
2016-11-10
Python
python中的裝飾器介紹
2018-07-10
Python
Python 的閉包和裝飾器
2016-05-05
Python
瞭解python的裝飾器特性
2024-04-09
Python
Python3 裝飾器解析
2020-07-18
Python
Python 語法之裝飾器
2019-12-19
Python
Python裝飾器高階用法
2019-02-24
Python
python裝飾器入門探究
2019-03-01
Python
python 裝飾器 part2
2019-02-16
Python

Python: 會打扮的裝飾器

對一個簡單的函式進行裝飾

裝飾器的使用形式

對帶引數的函式進行裝飾

帶引數的裝飾器

多個裝飾器

基於類的裝飾器

裝飾器的副作用

參考資料

相關文章