大家好，我是早起。

之前的文章中提到，很多人認為理解了裝飾器的概念和用法后，會覺得自己的 Python 水平有一個明顯的提高。

但很多教程在一上來就會給出裝飾器的定義以及基本用法，例如你一定會在很多文章中看到例如代碼運行時間計時器等相關常用裝飾器。

直接從應用入手這樣學習當然十分有效，但不是看過就忘就是似懂非懂的狀態，因為裝飾器從來就不是一個單獨的概念，就像數學分析中求積分一樣，你可以通過公式快速算出需要求的積分，但是若明白積分是由極限定義的，之后再看積分將會是不一樣的視角。

本文我將嘗試說清楚為什么需要現裝飾器、什么是裝飾器、以及如何寫一個簡單的裝飾器，但要徹底理解裝飾器還要從函數開始說起，下面是有關函數的四個重要的概念，希望大家可以明白。

01.有關函數的四個重要概念

相信你在大多數文章中，至少也能知道例如「裝飾器是裝飾函數」，「在不修改函數代碼的情況下增加額外功能」等核心概念，但首先要知道為什么函數能夠被裝飾。

例如在《流暢的Python》一書中，講到函數的一開始就提出了一個概念，函數是一等對象

正如書中所說，在Python中一個函數既可以作為參數被傳遞，也能作為另一個函數的返回值，這也是函數可以被裝飾的關鍵，在介紹裝飾器之前，下面有必要通過簡單的代碼對這段話做一個更直觀的理解。

1.1 函數中傳遞函數

函數中傳遞函數意思就是可以將函數當作變量來使用，我們來看一個簡單的示例。

在下面的代碼中，func1是一個普通的函數，接受兩個參數a,b并返回他們的和。func2不一樣的地方在于多接收了一個func參數，這個func變量需要是一個函數 

def func1(a,b):  
        print(f"函數 {func1.__name__} 正在執行")     
    return a + b      
def func2(func,c,d):      
    print(f"函數 {func2.__name__} 正在執行")  
        return func(c,d) 

現在讓我們來執行func1 

>>> func1(1,2)  
函數 func1 正在執行  
3 

下面func1作為參數執行func2 

>>> func2(func1,3,4)  
函數 func2 正在執行  
函數 func1 正在執行  
7 

可以看到，先執行func2，在func2接收到fun1后，再次執行func1并返回。注意這里的func1沒有括號，它只不過是和a，b一樣的參數被使用，理解這點后我們繼續看下一個知識點。

1.2 函數中定義函數

在定義一個函數后，可以繼續在函數內部定義新的函數。為了理解這點，我們來看下面簡單的示例。

我們先定義了一個函數func1，并在func1中定義了func2，并在func1的內部調用了func2 

def func1():    
    print(f"函數 {func1.__name__} 正在執行")  
    def func2():          
        print(f"內部函數 {func2.__name__} 正在執行")        
     func2() 

現在執行func1與func2看看會發生什么 

>>> func1()  
函數 func1 正在執行  
內部函數 func2 正在執行  
>>> func2()  
------------------------------------------------  
Traceback (most recent call last)  
----> 1 func2()  
NameError: name 'func2' is not defined 

可以看到，當執行func1時，會自動執行func2，但是如果單獨執行func2，則提示未定義，說明func2只能在func1中被調用！

1.3 函數返回函數

最后是一個函數可以將另一個函數作為返回值返回的簡單示例，在下面的代碼中，我們先定義了一個外部函數func1（接受一個參數a），之后定義了一個內部函數func2（接受一個參數b）并返回a + b，最后將func2作為func1的返回值返回 

def func1(a):      
    print(f"函數 {func1.__name__} 正在執行")  
        def func2(b):       
         print(f"函數 {func2.__name__} 正在執行")  
                return a + b   
     return func2 

需要注意的是，這里返回的func2沒有括號，代表返回的是func2的地址！ 

>>> func3 = func1(1)  
>>> func3  
函數 func1 正在執行  
<function __main__.func1.<locals>.func2(b)>  
>>> func3(2)  
函數 func2 正在執行  
3 

從上面的運行結果可以看到，當執行func1(1)后，返回的是func2的地址，并賦給func3，之后執行func3(2)才真正執行了內部函數func2！

現在我們就解決了上一小節的問題「將內部函數func2單獨拿出來用」！

1.4 函數內省

函數內省是相對來說比較好理解的一個概念，在Python中的意思就是我們可以訪問函數的部分屬性，例如print函數，可以使用dir函數來查看其全部屬性 

>>> dir(print)  
['__call__',  
 '__class__',  
 '__delattr__',  
  ··· ···  
 '__subclasshook__', 
 '__text_signature__'] 

現在可以查看其對應的屬性 

>>> print.__name__  
'print'  
>>> print.__call__  
<method-wrapper '__call__' of builtin_function_or_method object at 0x7fddb8056b80>  
>>> print.__doc__  
"print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n\nPrints the values to a stream, or to sys.stdout by default.\nOptional keyword arguments:\nfile:  a file-like object (stream); defaults to the current sys.stdout.\nsep:   string inserted between values, default a space.\nend:   string appended after the last value, default a newline.\nflush: whether to forcibly flush the stream." 

函數內省了解到這個程度即可，我們會在2.3節再次提到這里的知識！

至此，我已經將接觸裝飾器之前必須要吃透的知識點介紹完畢，如果你覺得我講解的不夠清晰，可以查看任何其他教程或者書籍弄懂后再繼續閱讀。

02.  初識裝飾器

現在終于可以來說說裝飾器了，當然絕對不是直接告訴你一個寫好的裝飾器，而是我們一點一點去寫一個簡單的裝飾器。

2.1 第一個裝飾器

在下面的代碼中，我們先定義了一個函數first_decorator，該函數接受函數為參數（如果不理解請查看本文 1.1 節），之后在內部定義了一個名為name_wrapper的內部函數（如果不理解請查看本文 1.2 節），最后返回以name_wrapper作為返回值（如果不理解請查看本文 1.3 節） 

def first_decorator(func):  
    def name_wrapper():      
         print(f"被裝飾的函數 {func.__name__} 即將執行")  
        func()  
        print(f"被裝飾的函數 {func.__name__} 執行完畢")        
     return name_wrapper 

這個函數的功能是，在執行被接收函數前后分別打印一段話，所以我們要再定義一個函數來測試效果 

def add():      
    print("函數 add 正在執行 ") 

這個fun1沒有什么好說的，打印一段話。下面需要仔細看了，我們來執行這兩段代碼 

>>> add = first_decorator(add)  
>>> add()  
被裝飾的函數 add 即將執行  
函數 add 正在執行   
被裝飾的函數 add 執行完畢 

正如我們預料的一樣，在執行add前后都有一段提示，但是如果每次使用first_decorator功能都需要先將add傳遞，之后再調用，來回寫好幾遍，實在太麻煩了！

因此這完全有更Pythonic的寫法，也就是我們常見的裝飾器形式，使用語法糖@，例如上面的例子和下面的寫法等價 

@first_decorator  
def add():     
    print("函數 add 正在執行 ") 

用@+裝飾器函數名字放在需要被裝飾函數的上方即可，現在直接調用add即可實現裝飾器的功能！ 

>>> add()  
被裝飾的函數 add 即將執行  
函數 add 正在執行   
被裝飾的函數 add 執行完畢 

相信看到這里，你應該明白裝飾器@如何工作的，至少你在未來看到@時需要想到類似等價于add = first_decorator(add)一樣的作用！

2.2 裝飾器傳參

上面僅是最簡單的裝飾器示例，在實際使用時

很自然的想法那就是加上參數唄，改起來也不難 

@first_decorator  
def add(x,y):    
        print("函數 add 正在執行 ")  
    print(f"{x} + {y} 的結果為{x+y}") 

讓我們來測試一下 

>>> add(1,2)  
-----------------------------------------------  
Traceback (most recent call last)  
<ipython-input-144-944f4051a32c> in <module>  
----> 1 add(1,2) 
TypeError: name_wrapper() takes 0 positional arguments but 2 were given 

不出意外的報錯了，雖然我們給被裝飾的函數加上了參數，但是在裝飾器的內部函數name_wrapper()執行時并沒有參數！

因此我們之前的代碼可以這么改，使用*args, **kwargs也是非常常見的用法 

def first_decorator(func):  
    def name_wrapper(*args, **kwargs):       
         print(f"被裝飾的函數 {func.__name__} 即將執行")  
        func(*args, **kwargs)  
        print(f"被裝飾的函數 {func.__name__} 執行完畢")        
     return name_wrapper 

現在我們再次使用這個裝飾器即可返回我們預測的結果！ 

@first_decorator  
def add(x,y):      
    print("函數 add 正在執行 ") 
    print(f"{x} + {y} 的結果為 {x+y}")  
>>> add(1,2)  
被裝飾的函數 add 即將執行  
函數 add 正在執行   
1 + 2 的結果為 3  
被裝飾的函數 add 執行完畢 

03. functools

本文的最后，還需要簡單介紹一下在寫裝飾器時常用的functools模塊。

還記得1.4節的函數內省相關知識嗎？我們可以打印一個函數指向的內存地址或者名字等其他屬性。

還是上面用到的add函數，我們都知道雖然被裝飾了，但是功能上沒有任何變化，依舊是計算兩個數字的和，但是真的沒有任何變化嗎？下面讓我們來觀察一下 

def add(x,y):      
    print("函數 add 正在執行 ")  
    print(f"{x} + {y} 的結果為{x+y}")  
    >>> print(add)  
<function add at 0x7fddb9dd41f0>  
>>>print(add.__name__)  
add    
@first_decorator  
def add(x,y):  
    print("函數 add 正在執行 ")  
    print(f"{x} + {y} 的結果為{x+y}")    
 >>> print(add)  
<function first_decorator.<locals>.name_wrapper at 0x7fddb9dd4e50>  
>>> print(add.__name__)  
name_wrapper 

可以看到，被裝飾后，雖然功能上沒有變化，但是它指向的是裝飾器所定義的內部函數！這并不是我們希望看到的，比如若不同函數被兩個裝飾器裝飾時則會出現一樣的函數名！

幸運的是Python中的functools庫可以輕松解決這個問題，只需要加上一行簡單的代碼就可以搞定！ 

import functools  
def first_decorator(func):  
    @functools.wraps(func)  
    def name_wrapper(*args, **kwargs):      
         print(f"被裝飾的函數 {func.__name__} 即將執行")  
        func(*args, **kwargs)  
        print(f"被裝飾的函數 {func.__name__} 執行完畢")       
     return name_wrapper 
 @first_decorator  
def add(x,y):    
     print("函數 add 正在執行 ")  
    print(f"{x} + {y} 的結果為{x+y}")    
 >>> print(add)  
<function add at 0x7fddb9dd4e50>  
>>> print(add.__name__)  
add 

可以看到此時函數名等函數屬性均保留下來了，事實上@functools.wraps(func)通過functools.update_wrapper()將原函數中的部分內省屬性固定，只傳遞部分關鍵參數來實現這個功能，感興趣的讀者可以自行進一步研究。

至此，我想你應該明白為什么需要現裝飾器、什么是裝飾器、以及如何寫一個簡單的裝飾器，當你再次看到裝飾器時，腦海中浮現的概念應該不僅僅是@。有關裝飾器更高級的用法，以及一些常見、好用的裝飾器，我將在裝飾器的第二篇文章中進行介紹！