1、裝飾器基礎介紹
1.1 何為Python中的裝飾器？
Python中裝飾器的定義以及用途：
裝飾器是一種特殊的函式，它可以接受一個函式作為引數，並返回一個新的函式。裝飾器可以用來修改或增強函式的行為，而不需要修改函式本身的程式碼。在Python中，裝飾器通常用於實現AOP（面向切面程式設計），例如日誌記錄、效能分析、快取等。裝飾器的語法使用@符號，將裝飾器函式放在被裝飾函式的定義之前
學過設計模式的朋友都知道，設計模式的結構型模式中也有一個叫裝飾器模式，那這個和Python中的裝飾器有什麼不同呢？
設計模式中的裝飾器的定義以及用途：
設計模式中的裝飾器是一種結構型模式，它可以在不改變原物件的情況下，為物件新增額外的功能。裝飾器模式通常用於在執行時動態地為物件新增功能，而不是在編譯時靜態地為物件新增功能。裝飾器模式通常涉及到多個物件之間的協作，而不是單個函式或物件。
因此，Python中的裝飾器和設計模式中的裝飾器雖然名稱相同，但是它們的實現方式和應用場景有很大的不同。
1.2 閉包
那Python種的裝飾器是怎麼實現的呢？先不用著急，我們先來一起學習學習Python中的閉包。
那什麼叫做閉包呢？
閉包是指一個函式和它所在的環境變數的組合，即在函式內部定義的函式可以訪問外部函式的變數和引數，即使外部函式已經返回。閉包可以用來實現函數語言程式設計中的柯里化、惰性求值、函式組合等高階特性。
看著上面的文字，是不是感覺有點抽象。我說一說我對閉包的理解
閉包是由外部函式和內部函式，內部函式引用到了外部函式定義的變數，外部函式的返回值是內部函式的函式名。對於這樣的函式，我們就稱為閉包。
好像也有點抽象，我們來看一斷程式碼，就能夠理解上面的話了。
def my_decorator(): # my_decorator 這個就叫做外部函式
a = 1
def inner(): # inner 這個叫做內部函式
print(a) # 內部函式引用到了外部函式中定義的變數
return inner # 外部函式的返回值是內部函式名
2、函式裝飾器的實現
上面講解了裝飾器的定義、用途，還有閉包，那怎麼去實現一個裝飾器呢？不急，接下來我們一起來學習如何實現裝飾器。
裝飾器不是說可以不改變一個函式原始碼的基礎上，給這個函式新增額外的功能嗎？那怎麼做呢？
接下來，我們就一起實現一個裝飾器，來計算函式的執行時間。Let‘s go!
2.1 不使用@實現裝飾器
首先，使用閉包定義一個統計函式執行時間的功能。
def process_time(func):
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函式的執行時間為:%d" % (end_time-start_time))
return ret
return inner
接下來定義一個函式，使用比較來計算函式的執行時間。
import time
def process_time(func):
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函式的執行時間為:%d" % (end_time-start_time))
return ret
return inner
def test(sleep_time):
time.sleep(sleep_time)
t1 = process_time(test)
t1(1)
print("------------")
t1(2)
執行結果：
函式的執行時間為:1
------------
函式的執行時間為:2
透過上面的程式碼，我們觀察到，我們並沒有修改test函式的原始碼，依舊給test函式新增上了統計函式執行時間的功能。
Python中實現上述功能，有更加優雅的方式。下面，我們就一起來看看如何實現的。
2.2 Python中使用語法糖的裝飾器(推薦使用)
import time
def process_time(func):
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函式的執行時間為:%d" % (end_time-start_time))
return ret
return inner
@process_time
def test(sleep_time):
time.sleep(sleep_time)
test(1)
print("------------")
test(2)
執行結果：
函式的執行時間為:1
------------
函式的執行時間為:2
觀察上面的程式碼變動，發現只有很少的部分修改了。
1、test函式上面新增了一行@process_time。
2、test函式的呼叫方式發生了改變。
其他的並沒有發生變化，整個程式碼看起來也更加清爽了。
提示：
當使用@裝飾器時，會自動執行 閉包中的外部函式內容。這個可以自行驗證。
當使用@裝飾器時，Python直譯器為我們做了什麼？
當使用@裝飾器時，Python直譯器會將被裝飾的函式作為引數傳遞給裝飾器函式，並將其返回值作為新的函式物件替換原來的函式物件。這樣，每次呼叫被裝飾的函式時，實際上是呼叫了裝飾器函式返回的新函式物件。
Python 裝飾器 @ 實際上是一種語法糖，它可以讓我們在不改變原函式程式碼的情況下，對函式進行擴充套件或修改。當我們使用 @ 裝飾器時，實際上是將被裝飾函式作為引數傳遞給裝飾器函式，然後將裝飾器函式的返回值賦值給原函式名。因此，@ 裝飾器並不會進行記憶體複製。
透過下面的函式，可以得知，inner和test函式指向的是同一個記憶體地址。
import time
def process_time(func):
print("func id --->", id(func))
def inner(*args, **kwargs):
start_time = time.time()
ret = func(*args, **kwargs)
end_time = time.time()
print("函式的執行時間為:%d" % (end_time - start_time))
return ret
print("inner id --->", id(inner))
return inner
@process_time
def test(sleep_time):
print("test func id --->", id(test))
time.sleep(sleep_time)
print("test id --->", id(test))
執行結果：
func id ---> 4312377952
inner id ---> 4313983008
test id ---> 4313983008
使用語法糖時，Python直譯器底層為我們做了這樣的處理。
2.3 多個裝飾器的執行順序
上面的兩個例子，都只有一個裝飾器，是不是Python只能寫一個裝飾器呢。其實不是的。主要是為了講解簡單。接下來，我們一起來看看，多個裝飾器的執行順序。
def outer_1(func):
print("coming outer_1")
def inner_1():
print("coming inner_1")
func()
return inner_1
def outer_2(func):
print("coming outer_2")
def inner_2():
print("coming inner_2")
func()
return inner_2
def outer_3(func):
print("coming outer_3")
def inner_3():
print("coming inner_3")
func()
return inner_3
@outer_1
@outer_2
@outer_3
def test():
print("coming test")
test()
執行結果：
coming outer_3
coming outer_2
coming outer_1
coming inner_1
coming inner_2
coming inner_3
coming test
outer_3 -> outer_2 -> outer_1 -> inner_1 -> inner_2 -> inner_3 -> 被裝飾函式
從上面的執行結果，可以得出如下結論：
使用多個裝飾器裝飾函式時，
外部函式的執行順序是從下到上的。
內部函式的執行順序是從下往上的。
多個裝飾器裝飾函式時，Python直譯器底層做了啥
透過下面這段程式碼驗證
def outer_1(func):
print("coming outer_1, func id -->", id(func))
def inner_1():
print("coming inner_1")
func()
print("inner_1 id -->", id(inner_1))
return inner_1
def outer_2(func):
print("coming outer_2, func id -->", id(func))
def inner_2():
print("coming inner_2")
func()
print("inner_2 id -->", id(inner_2))
return inner_2
def outer_3(func):
print("coming outer_3, func id -->", id(func))
def inner_3():
print("coming inner_3")
func()
print("inner_3 id -->", id(inner_3))
return inner_3
@outer_1
@outer_2
@outer_3
def test():
print("coming test")
test()
執行結果：
coming outer_3, func id --> 4389102784
inner_3 id --> 4389102928
coming outer_2, func id --> 4389102928
inner_2 id --> 4389103072
coming outer_1, func id --> 4389103072
inner_1 id --> 4389103216
coming inner_1
coming inner_2
coming inner_3
coming test
2.4 帶引數的裝飾器
該如何實現帶引數的裝飾器呢，其實原理一樣的，我們再定義一個外層函式，外層函式的返回值是記憶體函式的名稱，即引用。
下面我們來看一個例子：
def is_process(flag):
def outer_1(func):
print("coming outer_1, func id -->", id(func))
def inner_1():
print("coming inner_1")
if flag:
func()
print("inner_1 id -->", id(inner_1))
return inner_1
return outer_1
@is_process(True)
def test():
print("coming test")
test()
注意：
- 我們裝飾函式時，裝飾器的寫法不同了，變成了
@is_process(True)，這裡是呼叫了is_process這個函式
3、函式裝飾器的注意點(wraps函式)
猜一猜下面函式會輸出什麼？
def outer_1(func):
def inner_1():
print("inner_1, func __name__", func.__name__)
print("inner_1, func __doc__", func.__doc__)
func()
return inner_1
@outer_1
def test():
"""this is test"""
print("outer_1, func __name__", test.__name__)
print("outer_1, func __doc__", test.__doc__)
test()
函式執行結果：
inner_1, func __name__ test
inner_1, func __doc__ this is test
test, test __name__ inner_1
test, test __doc__ None
注意到沒，在test函式體內列印函式的 __name__、__doc__ 屬性，居然變成內部函式的了。
這個是為什麼呢？
Python裝飾器在裝飾函式時，會將原函式的函式名、文件字串、引數列表等屬性複製到裝飾器函式中，但是裝飾器函式並不會複製原函式的所有屬性。例如，原函式的name屬性、doc屬性、module屬性等都不會被複制到裝飾器函式中。
為了避免這種情況，可以使用functools庫中的wraps裝飾器來保留原來函式物件的屬性。wraps裝飾器可以將原來函式物件的屬性複製到新的函式物件中，從而避免屬性丟失的問題。
from functools import wraps
def outer_1(func):
@wraps(func)
def inner_1():
print("inner_1, func __name__", func.__name__)
print("inner_1, func __doc__", func.__doc__)
func()
return inner_1
@outer_1
def test():
"""this is test"""
print("test, test __name__", test.__name__)
print("test, test __doc__", test.__doc__)
test()
執行結果：
inner_1, func __name__ test
inner_1, func __doc__ this is test
test, test __name__ test
test, test __doc__ this is test
4、類裝飾器
上面我們都是使用的函式來實現裝飾器的功能，那可不可以用類來實現裝飾器的功能呢？我們知道函式實現裝飾器的原理是外部函式的引數是被裝飾的函式，外部函式返回內部函式的名稱。內部函式中去執行被裝飾的函式。
那麼其實類也是可以用來實現裝飾器的，因為當我們為 類 定義了 __call__方法時，這個類就成了可呼叫物件，例項化後可直接呼叫。
class ProcessTime:
def __call__(self, *args, **kwargs):
print("call")
p = ProcessTime()
p()
4.1 類裝飾器的實現
import time
class ProcessTime:
def __init__(self, func):
print("coming ProcessTime __init__")
self.func = func
def __call__(self, *args, **kwargs):
start_time = time.time()
print("coming ProcessTime __call__, id(self.func) -->", id(self.func))
ret = self.func(*args, **kwargs)
end_time = time.time()
print("ProcessTime 函式的執行時間為:%d" % (end_time - start_time))
return ret
@ProcessTime
def test(sleep_time):
time.sleep(sleep_time)
return "tet"
test(1)
執行結果：
coming ProcessTime __init__
coming ProcessTime __call__, id(self.func) --> 4488922160
ProcessTime 函式的執行時間為:1
透過上面的執行結果，我們可以得到，@ProcessTime的作用是 test = ProcessTime(test)。又因為 ProcessTime定義了__call__方法，是可呼叫物件，所以可以像函式那樣直接呼叫例項化ProcessTime後的物件。
這裡可以驗證，透過註釋掉裝飾器，手動初始化ProcessTime類。得到的結果是一樣的。
# @ProcessTime
def test(sleep_time):
time.sleep(sleep_time)
return "tet"
test = ProcessTime(test)
test(1)
4.2 多個類裝飾器的執行順序
多個類裝飾器的執行順序是怎麼樣的呢，這裡我們也透過程式碼來進行驗證。
import time
class ProcessTime:
def __init__(self, func):
print("coming ProcessTime __init__", id(self))
self.func = func
def __call__(self, *args, **kwargs):
start_time = time.time()
print("coming ProcessTime __call__, id(self.func) -->", id(self.func))
ret = self.func(*args, **kwargs)
end_time = time.time()
print("ProcessTime 函式的執行時間為:%d" % (end_time - start_time))
return ret
class ProcessTime2:
def __init__(self, func):
print("coming ProcessTime2 __init__", id(self))
self.func = func
def __call__(self, *args, **kwargs):
start_time = time.time()
print("coming ProcessTime2 __call__, id(self.func) -->", id(self.func))
ret = self.func(*args, **kwargs)
end_time = time.time()
print("ProcessTime2 函式的執行時間為:%d" % (end_time - start_time))
return ret
@ProcessTime
@ProcessTime2
def test(sleep_time):
time.sleep(sleep_time)
return "tet"
# test = ProcessTime2(test)
# test = ProcessTime(test)
t = test(1)
執行結果：
coming ProcessTime2 __init__ 4472235104
coming ProcessTime __init__ 4473162672
coming ProcessTime __call__, id(self.func) --> 4472235104
coming ProcessTime2 __call__, id(self.func) --> 4471735344
ProcessTime2 函式的執行時間為:1
ProcessTime 函式的執行時間為:1
從上面的結果，我們得到，執行順序是：
ProcessTime2 中的__init__ -> ProcessTime 中的__init__ -> ProcessTime 中的__call__ -> ProcessTime2 中的__call__
特別注意：
ProcessTime 中的__call__中的程式碼並不會執行完後再去執行ProcessTime2 中的__call__，而是在呼叫ret = self.func(*args, **kwargs)方法後，就回去執行ProcessTime2 中的__call__的程式碼。
4.3 類裝飾器存在的問題
其實，類裝飾器也存在和函式裝飾器一樣的問題。它會覆蓋原函式的後設資料資訊，例如函式名、文件字串、引數列表等。這可能會導致一些問題，例如除錯時無法正確顯示函式名、文件生成工具無法正確生成文件等。
import time
from functools import wraps
class ProcessTime:
def __init__(self, func):
print("coming ProcessTime __init__", id(self))
self.func = func
def __call__(self, *args, **kwargs):
start_time = time.time()
print("coming ProcessTime __call__, id(self.func) -->", id(self.func))
ret = self.func(*args, **kwargs)
end_time = time.time()
print("ProcessTime 函式的執行時間為:%d" % (end_time - start_time))
return ret
@ProcessTime
def test(sleep_time):
"tets"
print("test.__doc__", test.__doc__)
# print(test.__name__) --> 報錯，AttributeError: 'ProcessTime' object has no attribute '__name__'
time.sleep(sleep_time)
return "tet"
t = test(1)
那類裝飾器該如何解決呢？
我現在還不知道該如何處理，如果有知道的朋友，請不吝賜教，十分感謝！！
5、多個裝飾器的執行順序總結
其實，我覺得不用特別的去記多個裝飾器的執行順序是如何的，我們最重要的是理解到裝飾器的執行邏輯是如何的。函式裝飾器和類裝飾器的初始化順序都是一樣的：從靠近被裝飾的函式開始執行初始化操作。把這個核心原理理解到後，多個裝飾器的執行順序在使用的時候，就很容易得到了。
