python裝飾器深入學(xué)習

什么是裝飾器

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

裝飾器遵循的原則

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

函數(shù)名即“變量”

在python中，函數(shù)名其實就像是c語言的函數(shù)指針，代表的是我們的函數(shù)地址，只有解釋器獲取到這個地址，它才會去執(zhí)行這塊內(nèi)存的代碼。因此，本質(zhì)上，函數(shù)名就和不同變量沒什么區(qū)別，只不過函數(shù)名和普通變量所指代的那塊內(nèi)存的使用方式不同罷了，這些都是底層解釋器的機制所決定的，對于程序猿來說，都是透明的，所以，我們可以認為兩者是沒有區(qū)別的。

高階函數(shù)

什么是高階函數(shù)其實很簡單，把握兩個原則就好：

• 形式參數(shù)有函數(shù)名
• 返回值有函數(shù)名
  

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

嵌套函數(shù)

什么是嵌套函數(shù)其實也非常簡單，把握一個原則就好：

• 在一個函數(shù)的函數(shù)體中去定義另一個函數(shù)
  

在這里需要強調(diào)的是，函數(shù)定義時是不會執(zhí)行函數(shù)體的，就和定義變量是不會去讀取變量里的內(nèi)容一樣。這一點至關(guān)重要，對于我們理解裝飾器實現(xiàn)原理非常有幫助。

如何寫裝飾器

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

裝飾器本質(zhì)

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

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

 這個示例就是python中如何修飾func函數(shù)的格式，當然我們還沒有實現(xiàn)我們的裝飾器函數(shù)。我們要注意的是注釋里寫的內(nèi)容，我們可以看出：

• 裝飾器函數(shù)其實是一個高階函數(shù)(參數(shù)和返回值都為函數(shù)名)。
• “auth(func)”是在調(diào)用我們的裝飾器函數(shù)，即裝飾器函數(shù)的函數(shù)體會被執(zhí)行，一定要記好這一點。
  

設(shè)計思路

裝飾器即然是個函數(shù)，又有上述介紹的等價關(guān)系，那我們就可以這樣設(shè)計我們的裝飾器：

• 在我們裝飾器的函數(shù)體內(nèi)去定義一個新的函數(shù)，在這個新定義的函數(shù)內(nèi)去調(diào)用被修飾的函數(shù)，與此同時，在被修飾的函數(shù)的上下文去添加新功能。最后，利用裝飾器函數(shù)的返回值返回我們新定義函數(shù)的函數(shù)名。
  
• 由此可以知道，“func = auth(func)”中的返回值func表示的就是在裝飾器中新定義的函數(shù)的函數(shù)名。

前面做了大量的鋪墊，就是想在這里揭示裝飾器的實現(xiàn)機制，其實沒什么什么的，很簡單：

• 裝飾器機制改變了被修飾函數(shù)的函數(shù)名表示的地址數(shù)據(jù)。說白了就是，被修飾前，函數(shù)名代表的是A內(nèi)存塊；被修飾后，函數(shù)名代表的是B內(nèi)存塊；只不過，在執(zhí)行B內(nèi)存塊時，會調(diào)用A內(nèi)存塊罷了。B內(nèi)存塊中的代碼就是我們新加的功能。而這種機制的實現(xiàn)，使用了“高階函數(shù)”和“嵌套函數(shù)”的機制。
  
• 最終的效果就是，但在調(diào)用被修飾過的函數(shù)時，其實調(diào)用的不是原來的內(nèi)存塊，而是修飾器新申請的內(nèi)存塊。

第一步：設(shè)計裝飾器函數(shù)

裝飾器函數(shù)定義跟普通函數(shù)定義沒什么區(qū)別，關(guān)鍵是函數(shù)體怎么寫的問題。這里，為了便于理解，先用無參數(shù)的裝飾器函數(shù)說明。

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

這里說的無參數(shù)，指的是沒有除了“func”之外的參數(shù)
難點是函數(shù)體的編寫，下面的示例先告訴你為什么要有第二步：

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

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

第二步：包裝被修飾函數(shù)

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

 下面給出個示例：

#使用內(nèi)嵌包裝函數(shù)來確保每次新函數(shù)都被調(diào)用，
#內(nèi)嵌包裝函數(shù)的形參和返回值與原函數(shù)相同，裝飾函數(shù)返回內(nèi)嵌包裝函數(shù)對象
 
def deco(func):
 def _deco():
 print("before myfunc() called.")
 func()
 print("after myfunc() called.")
 # 不需要返回func，實際上應(yīng)返回原函數(shù)的返回值
 return _deco
 
@deco
def myfunc():
 print("myfunc() called.")
 return 'ok'
 
myfunc()
 
#output:
before myfunc() called.
myfunc() called.
after myfunc() called.

  第三步：被修飾函數(shù)參數(shù)和返回值透明化處理

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

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

通過上面的分析知：

參數(shù)透明化：當我們在調(diào)用被裝飾后的函數(shù)時，其實調(diào)用的時這里的_deco函數(shù)。那么，我們就給_deco函數(shù)加上可變參數(shù)，并把得到的可變參數(shù)傳遞給func函數(shù)不就可以了。
返回值透明化：和參數(shù)透明化同理，給_deco函數(shù)定義返回值，并返回func的返回值就可以了。

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

#對帶參數(shù)的函數(shù)進行裝飾，
#內(nèi)嵌包裝函數(shù)的形參和返回值與原函數(shù)相同，裝飾函數(shù)返回內(nèi)嵌包裝函數(shù)對象
 
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
 
@deco
def 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: 3
sum= 3
before myfunc() called.
 myfunc(3,4) called.
 after myfunc() called. result: 7
sum= 7

裝飾器進階

帶參數(shù)裝飾器

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

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

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

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

#示例7: 在示例4的基礎(chǔ)上，讓裝飾器帶參數(shù)，
#和上一示例相比在外層多了一層包裝。
#裝飾函數(shù)名實際上應(yīng)更有意義些
 
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].

多重裝飾器修飾函數(shù)

如果說，我上面說的內(nèi)容都理解了，那么這個東東，就太簡單不過了。不就是把我們的是裝飾器當中被修飾的函數(shù)，對它進行裝飾嗎？但我在這里還想說的是，我們換個角度看問題。我們的關(guān)注點放在原來的被修飾的函數(shù)上，就會發(fā)現(xiàn)，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].

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

領(lǐng)取干貨：零基礎(chǔ)入門學(xué)習python視頻教程

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習有所幫助，也希望大家多多支持億速云。