python裝飾器深入學習_python

這篇文章主要深入學習了python裝飾器的相關資料,什麼是裝飾器？裝飾器遵循的原則等，具有一定的參考價值，感興趣的小夥伴們可以參考一下

什麼是裝飾器

在我們的軟體產品升級時，常常需要給各個函數新增功能，而在我們的軟體產品中，相同的函數可能會被調用上百次，這種情況是很常見的，如果我們一個個的修改，那我們的碼農豈不要掛掉了(有人就說了 ，你笨呀，修改函數定義不就行了！同學，你醒醒吧，如果要新加的功能會修改參數，或者傳回值呢？)。這個時候，就是我們裝飾器大顯神通的時候了。裝飾器就可以實現，在不改變原函數的調用形式下（即函數的透明化處理），給函數新增功能的作用。如何?，以及實現原理，下文會詳解。

裝飾器遵循的原則

裝飾器，顧名思義就是起裝飾的作用，既然是裝飾，那麼被裝飾的對象是啥樣就是啥樣，不能有絲毫改變。在這裡，我們寫裝飾器就是必須把握不能修改被修飾函數的原始碼這條鐵律。如何遵循這條鐵律，我們還需還需做一些鋪墊，必須先要瞭解三個概念，如下：

函數名即“變數”

在python中，函數名其實就像是c語言的函數指標，代表的是我們的函數地址，只有解譯器擷取到這個地址，它才會去執行這塊記憶體的代碼。因此，本質上，函數名就和不同變數沒什麼區別，只不過函數名和普通變數所指代的那塊記憶體的使用方式不同罷了，這些都是底層解譯器的機制所決定的，對於程式猿來說，都是透明的，所以，我們可以認為兩者是沒有區別的。

高階函數

什麼是高階函數其實很簡單，把握兩個原則就好：

• 形式參數有函數名

• 傳回值有函數名
  

只要滿足這兩個原則之一，就可以稱之為是高階函數。翻回頭來看，這裡出現了我們上面說的函數名，仔細體會一下，我們在這裡不就是把其當成實參看待的嗎？

嵌套函數

什麼是嵌套函數其實也非常簡單，把握一個原則就好：

• 在一個函數的函數體中去定義另一個函數
  

在這裡需要強調的是，函數定義時是不會執行函數體的，就和定義變數是不會去讀取變數裡的內容一樣。這一點至關重要，對於我們理解裝飾器實現原理非常有協助。

如何寫裝飾器

有了上文的鋪墊，在現在來詳解一下如何寫裝飾器，就好理解多了。

裝飾器本質

　　其實裝飾器本質上就是一個函數，它也具有函數名，參數和傳回值。但在python中，我們用“@auth”來表示。

@auth    # 其等價於：func = auth(func)def func():  print("func called")

這個樣本就是python中如何修飾func函數的格式，當然我們還沒有實現我們的裝飾器函數。我們要注意的是注釋裡寫的內容，我們可以看出：

• 裝飾器函數其實是一個高階函數(參數和傳回值都為函數名)。

• “auth(func)”是在調用我們的裝飾器函數，即裝飾器函數的函數體會被執行，一定要記好這一點。
  

設計思路

裝飾器即然是個函數，又有上述介紹的等價關係，那我們就可以這樣設計我們的裝飾器：

• 在我們裝飾器的函數體內去定義一個新的函數，在這個新定義的函數內去調用被修飾的函數，與此同時，在被修飾的函數的上下文去添加新功能。最後，利用裝飾器函數的傳回值返回我們新定義函數的函數名。
  

• 由此可以知道，“func = auth(func)”中的傳回值func表示的就是在裝飾器中新定義的函數的函數名。

前面做了大量的鋪墊，就是想在這裡揭示裝飾器的實現機制，其實沒什麼什麼的，很簡單：

• 裝飾器機制改變了被修飾函數的函數名表示的地址資料。說白了就是，被修飾前，函數名代表的是A記憶體塊；被修飾後，函數名代表的是B記憶體塊；只不過，在執行B記憶體塊時，會調用A記憶體塊罷了。B記憶體塊中的代碼就是我們新加的功能。而這種機制的實現，使用了“高階函數”和“嵌套函數”的機制。
  

• 最終的效果就是，但在調用被修飾過的函數時，其實調用的不是原來的記憶體塊，而是修飾器新申請的記憶體塊。

第一步：設計裝飾器函數

裝飾器函數定義跟普通函數定義沒什麼區別，關鍵是函數體怎麼寫的問題。這裡，為了便於理解，先用無參數的裝飾器函數說明。

#裝飾器函數定義格式def deco(func):  '''函數體...'''return func

這裡說的無參數，指的是沒有除了“func”之外的參數
痛點是函數體的編寫，下面的樣本先告訴你為什麼要有第二步：

#使用文法糖@來裝飾函數，相當於“myfunc = deco(myfunc)”def deco(func):  print("before myfunc() called.")  func()  print("after myfunc() called.")  return func @decodef myfunc():  print("myfunc() called.") myfunc()myfunc() #output：before myfunc() called.myfunc() called.after myfunc() called.myfunc() called.myfunc() called.

由輸出結果可以看出，我們的裝飾器並沒有生效。別跟我說裝飾器只生效了一次，那是大家忽略了“@deco”的等效機制。解釋到“@deco”時，會解釋成“myfunc = deco(myfunc)”。注意了，前面我提到了，這裡其實在調用deco函數的，因此，deco的函數體會被執行。所以output的前三行並不是調用myfunc函數時產生的效果，那有怎能說裝飾器生效了一次呢？第二步就是解決裝飾器沒生效的問題的。

第二步：封裝被修飾函數

#基本格式def deco(func):  def _deco()    #新增功能    #...    #...    func() #別修飾函數調用  return_deco

下面給出個樣本：

#使用內嵌封裝函數來確保每次新函數都被調用，#內嵌封裝函數的形參和傳回值與原函數相同，裝飾函數返回內嵌封裝函數對象 def deco(func):  def _deco():    print("before myfunc() called.")    func()    print("after myfunc() called.")    # 不需要返回func，實際上應返回原函數的傳回值  return _deco @decodef myfunc():  print("myfunc() called.")  return 'ok' myfunc() #output:before myfunc() called.myfunc() called.after myfunc() called.

第三步：被修飾函數參數和傳回值透明化處理

當完成了第二步時，其實裝飾器已經完成了主要部分，下面就是對被修飾函數的參數和傳回值的處理。這樣才能真正實現裝飾器的鐵律。話不多說，直接上代碼：

#基本格式def deco(func):  def _deco(*args, **kwargs) #參數透明化    #新增功能    #...    #...    res = func(*args, **kwargs) #別修飾函數調用    return res #傳回值透明化  return_deco

通過上面的分析知：

參數透明化：當我們在調用被裝飾後的函數時，其實調用的時這裡的_deco函數。那麼，我們就給_deco函數加上可變參數，並把得到的可變參數傳遞給func函數不就可以了。
傳回值透明化：和參數透明化同理，給_deco函數定義傳回值，並返回func的傳回值就可以了。

透明化處理就是這麼簡單！至此，我們的裝飾器編寫完成。給個樣本吧：

#對帶參數的函數進行裝飾，#內嵌封裝函數的形參和傳回值與原函數相同，裝飾函數返回內嵌封裝函數對象 def deco(func):  def _deco(*agrs, **kwagrs):    print("before myfunc() called.")    ret = func(*agrs, **kwagrs)    print(" after myfunc() called. result: %s" % ret)    return ret  return _deco @decodef myfunc(a, b):  print(" myfunc(%s,%s) called." % (a, b))  return a + b print("sum=",myfunc(1, 2))print("sum=",myfunc(3, 4)) #output:before myfunc() called. myfunc(1,2) called. after myfunc() called. result: 3sum= 3before myfunc() called. myfunc(3,4) called. after myfunc() called. result: 7sum= 7

裝飾器進階

帶參數裝飾器

裝飾器即然也是函數，那麼我們也可以給其傳遞參數。我這裡說的是：“@auth(auth_type = 'type1')”這中形式喲。先上個代碼吧：

#基本格式def deco(deco_type)  def _deco(func):    def __deco(*args, **kwargs) #參數透明化      #新增功能      #...      #...      print("deco_type:",deco_type) #使用裝飾器參數      res = func(*args, **kwargs) #別修飾函數調用      return res #傳回值透明化    return __deco  return_deco

說白了，就是在原來的裝飾器的基礎上再在最外層套一個deco函數，並用其來接收裝飾器參數。由於是在最外層套了一個函數，那麼這個函數的形參的作用範圍就是函數體內部，所以裡面的函數定義中隨便用啦，就這麼任性。
那怎麼理解解譯器的解析過程呢？在這裡，只要我們明白一點就好，那就是： “@auth(auth_type = 'type1')”等價於“func = auth(auth_type = 'type1')(func)” 。解譯器會先翻譯“auth(auth_type = 'type1')”，再將其傳回值(假設給了_func這個不存在的函數名)當作函數指標，這裡的_func函數名代表的是_deco，然後再去執行“func = _func(func)”，而這個func函數名代表的其實就是__deco。

至此，就達到了通過裝飾器來傳參的目的。給個樣本吧：

#樣本7: 在樣本4的基礎上，讓裝飾器帶參數，#和上一樣本相比在外層多了一層封裝。#裝飾函數名實際上應更有意義些 def deco(deco_type):  def _deco(func):    def __deco(*args, **kwagrs):      print("before %s called [%s]." % (func.__name__, deco_type))      func(*args, **kwagrs)      print(" after %s called [%s]." % (func.__name__, deco_type))    return __deco  return _deco @deco("mymodule")def myfunc():  print(" myfunc() called.") @deco("module2")def myfunc2():  print(" myfunc2() called.") myfunc()myfunc2() #output:before myfunc called [mymodule]. myfunc() called. after myfunc called [mymodule].before myfunc2 called [module2]. myfunc2() called. after myfunc2 called [module2].

多重裝飾器修飾函數

如果說，我上面說的內容都理解了，那麼這個東東，就太簡單不過了。不就是把我們的是裝飾器當中被修飾的函數，對它進行裝飾嗎？但我在這裡還想說的是，我們換個角度看問題。我們的關注點放在原來的被修飾的函數上，就會發現，NB呀，我可以給它添加若干個功能撒。給個樣本吧：

def deco(deco_type):  def _deco(func):    def __deco(*args, **kwagrs):      print("before %s called [%s]." % (func.__name__, deco_type))      func(*args, **kwagrs)      print(" after %s called [%s]." % (func.__name__, deco_type))    return __deco  return _deco @deco("module1")@deco("mymodule")def myfunc():  print(" myfunc() called.") @deco("module2")def myfunc2():  print(" myfunc2() called.") myfunc() #output：before __deco called [module1].before myfunc called [mymodule]. myfunc() called. after myfunc called [mymodule]. after __deco called [module1].

注意結果喲，@deco("module1"),來修飾的deco("mymdule")的，和我們想的是一樣的，完美！