python裝飾器是什么意思

裝飾器是程序開發(fā)中經(jīng)常會用到的一個功能，用好了裝飾器，開發(fā)效率如虎添翼，所以這也是Python面試中必問的問題，但對于好多小白來講，這個功能 有點繞，自學時直接繞過去了，然后面試問到了就掛了，因為裝飾器是程序開發(fā)的基礎知識，這個都 不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。

作為一家“創(chuàng)意+整合+營銷”的成都網(wǎng)站建設機構，我們在業(yè)內良好的客戶口碑。創(chuàng)新互聯(lián)提供從前期的網(wǎng)站品牌分析策劃、網(wǎng)站設計、成都做網(wǎng)站、網(wǎng)站建設、創(chuàng)意表現(xiàn)、網(wǎng)頁制作、系統(tǒng)開發(fā)以及后續(xù)網(wǎng)站營銷運營等一系列服務，幫助企業(yè)打造創(chuàng)新的互聯(lián)網(wǎng)品牌經(jīng)營模式與有效的網(wǎng)絡營銷方法,創(chuàng)造更大的價值。

1、先明白這段代碼

####?第一波?####

def?foo():

print?'foo'

foo?????#表示是函數(shù)

foo()???#表示執(zhí)行foo函數(shù)

####?第二波?####

def?foo():

print?'foo'

foo?=?lambda?x:?x?+?1

foo()???#?執(zhí)行下面的lambda表達式，而不再是原來的foo函數(shù)，因為函數(shù)?foo?被重新定義了

2、需求來了

初創(chuàng)公司有N個業(yè)務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：數(shù)據(jù)庫操作、redis調用、監(jiān)控API等功能。業(yè)務部門使用基礎功能時，只需調用基礎平臺提供的功能即可。如下：

###############?基礎平臺提供的功能如下?###############

def?f1():

print?'f1'

def?f2():

print?'f2'

def?f3():

print?'f3'

def?f4():

print?'f4'

###############?業(yè)務部門A?調用基礎平臺提供的功能?###############

f1()

f2()

f3()

f4()

###############?業(yè)務部門B?調用基礎平臺提供的功能?###############

f1()

f2()

f3()

f4()

目前公司有條不紊的進行著，但是，以前基礎平臺的開發(fā)人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用。現(xiàn)在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能添加驗證機制，即：執(zhí)行功能前，先進行驗證。

老大把工作交給 Low B，他是這么做的：

跟每個業(yè)務部門交涉，每個業(yè)務部門自己寫代碼，調用基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。

當天Low B 被開除了…

老大把工作交給 Low BB，他是這么做的：

###############?基礎平臺提供的功能如下?###############

def?f1():

#?驗證1

#?驗證2

#?驗證3

print?'f1'

def?f2():

#?驗證1

#?驗證2

#?驗證3

print?'f2'

def?f3():

#?驗證1

#?驗證2

#?驗證3

print?'f3'

def?f4():

#?驗證1

#?驗證2

#?驗證3

print?'f4'

###############?業(yè)務部門不變?###############

###?業(yè)務部門A?調用基礎平臺提供的功能###

f1()

f2()

f3()

f4()

###?業(yè)務部門B?調用基礎平臺提供的功能?###

f1()

f2()

f3()

f4()

過了一周 Low BB 被開除了…

老大把工作交給 Low BBB，他是這么做的：

只對基礎平臺的代碼進行重構，其他業(yè)務部門無需做任何修改

###############?基礎平臺提供的功能如下?###############

def?check_login():

#?驗證1

#?驗證2

#?驗證3

pass

def?f1():

check_login()

print?'f1'

def?f2():

check_login()

print?'f2'

def?f3():

check_login()

print?'f3'

def?f4():

check_login()

print?'f4'

老大看了下Low BBB 的實現(xiàn)，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：

老大說：

寫代碼要遵循開發(fā)封閉原則，雖然在這個原則是用的面向對象開發(fā)，但是也適用于函數(shù)式編程，簡單來說，它規(guī)定已經(jīng)實現(xiàn)的功能代碼不允許被修改，但可以被擴展，即：

封閉：已實現(xiàn)的功能代碼塊

開放：對擴展開發(fā)

如果將開放封閉原則應用在上述需求中，那么就不允許在函數(shù) f1 、f2、f3、f4的內部進行修改代碼，老板就給了Low BBB一個實現(xiàn)方案：

def?w1(func):

def?inner():

#?驗證1

#?驗證2

#?驗證3

return?func()

return?inner

@w1

def?f1():

print?'f1'

@w1

def?f2():

print?'f2'

@w1

def?f3():

print?'f3'

@w1

def?f4():

print?'f4'

對于上述代碼，也是僅僅對基礎平臺的代碼進行修改，就可以實現(xiàn)在其他人調用函數(shù) f1 f2 f3 f4 之前都進行【驗證】操作，并且其他業(yè)務部門無需做任何操作。

Low BBB心驚膽戰(zhàn)的問了下，這段代碼的內部執(zhí)行原理是什么呢？

老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：

單獨以f1為例：

def?w1(func):

def?inner():

#?驗證1

#?驗證2

#?驗證3

return?func()

return?inner

@w1

def?f1():

print?'f1'

當寫完這段代碼后（函數(shù)未被執(zhí)行、未被執(zhí)行、未被執(zhí)行），python解釋器就會從上到下解釋代碼，步驟如下：

def w1(func): ?==將w1函數(shù)加載到內存

@w1

沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數(shù)在沒有被調用之前其內部代碼不會被執(zhí)行。

從表面上看解釋器著實會執(zhí)行這兩句，但是 @w1 這一句代碼里卻有大文章，@函數(shù)名?是python的一種語法糖。

如上例@w1內部會執(zhí)行一下操作：

執(zhí)行w1函數(shù)，并將 @w1 下面的?函數(shù)?作為w1函數(shù)的參數(shù)，即：@w1 等價于 w1(f1)

所以，內部就會去執(zhí)行：

def inner:

#驗證

return f1() ? # func是參數(shù)，此時 func 等于 f1

return inner ? ? # 返回的 inner，inner代表的是函數(shù)，非執(zhí)行函數(shù)

其實就是將原來的 f1 函數(shù)塞進另外一個函數(shù)中

將執(zhí)行完的 w1 函數(shù)返回值賦值給@w1下面的函數(shù)的函數(shù)名

w1函數(shù)的返回值是：

def inner:

#驗證

return 原來f1() ?# 此處的 f1 表示原來的f1函數(shù)

然后，將此返回值再重新賦值給 f1，即：

新f1 =?def inner:

#驗證

return 原來f1()

所以，以后業(yè)務部門想要執(zhí)行 f1 函數(shù)時，就會執(zhí)行 新f1 函數(shù)，在 新f1 函數(shù)內部先執(zhí)行驗證，再執(zhí)行原來的f1函數(shù)，然后將 原來f1 函數(shù)的返回值 返回給了業(yè)務調用者。

如此一來， 即執(zhí)行了驗證的功能，又執(zhí)行了原來f1函數(shù)的內容，并將原f1函數(shù)返回值 返回給業(yè)務調用著

Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家?guī)湍憬鉀Q吧！！！

先把上述流程看懂，之后還會繼續(xù)更新…

3、問答時間

問題：被裝飾的函數(shù)如果有參數(shù)呢？

#一個參數(shù)

def?w1(func):

def?inner(arg):

#?驗證1

#?驗證2

#?驗證3

return?func(arg)

return?inner

@w1

def?f1(arg):

print?'f1'

#兩個參數(shù)

def?w1(func):

def?inner(arg1,arg2):

#?驗證1

#?驗證2

#?驗證3

return?func(arg1,arg2)

return?inner

@w1

def?f1(arg1,arg2):

print?'f1'

#三個參數(shù)

def?w1(func):

def?inner(arg1,arg2,arg3):

#?驗證1

#?驗證2

#?驗證3

return?func(arg1,arg2,arg3)

return?inner

@w1

def?f1(arg1,arg2,arg3):

print?'f1'

問題：可以裝飾具有處理n個參數(shù)的函數(shù)的裝飾器？

def?w1(func):

def?inner(*args,**kwargs):

#?驗證1

#?驗證2

#?驗證3

return?func(*args,**kwargs)

return?inner

@w1

def?f1(arg1,arg2,arg3):

print?'f1'

問題：一個函數(shù)可以被多個裝飾器裝飾嗎？

def?w1(func):

def?inner(*args,**kwargs):

#?驗證1

#?驗證2

#?驗證3

return?func(*args,**kwargs)

return?inner

def?w2(func):

def?inner(*args,**kwargs):

#?驗證1

#?驗證2

#?驗證3

return?func(*args,**kwargs)

return?inner

@w1

@w2

def?f1(arg1,arg2,arg3):

print?'f1'

問題：還有什么更吊的裝飾器嗎？

#!/usr/bin/env?python

#coding:utf-8

def?Before(request,kargs):

print?'before'

def?After(request,kargs):

print?'after'

def?Filter(before_func,after_func):

def?outer(main_func):

def?wrapper(request,kargs):

before_result?=?before_func(request,kargs)

if(before_result?!=?None):

return?before_result;

main_result?=?main_func(request,kargs)

if(main_result?!=?None):

return?main_result;

after_result?=?after_func(request,kargs)

if(after_result?!=?None):

return?after_result;

return?wrapper

return?outer

@Filter(Before,?After)

def?Index(request,kargs):

print?'index'

如何理解Python裝飾器

內褲可以用來遮羞，但是到了冬天它沒法為我們防風御寒，聰明的人們發(fā)明了長褲，有了長褲后寶寶再也不冷了，裝飾器就像我們這里說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。

再回到我們的主題

裝飾器本質上是一個Python函數(shù)，它可以讓其他函數(shù)在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數(shù)對象。它經(jīng)常用于有切面需求的場景，比如：插入日志、性能測試、事務處理、緩存、權限校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數(shù)功能本身無關的雷同代碼并繼續(xù)重用。概括的講，裝飾器的作用就是為已經(jīng)存在的對象添加額外的功能。

先來看一個簡單例子：

def foo():

print('i am foo')

現(xiàn)在有一個新的需求，希望可以記錄下函數(shù)的執(zhí)行日志，于是在代碼中添加日志代碼：

def foo():

print('i am foo')

logging.info("foo is running")

bar()、bar2()也有類似的需求，怎么做？再寫一個logging在bar函數(shù)里？這樣就造成大量雷同的代碼，為了減少重復寫代碼，我們可以這樣做，重新定義一個函數(shù)：專門處理日志 ，日志處理完之后再執(zhí)行真正的業(yè)務代碼

def use_logging(func):

logging.warn("%s is running" % func.__name__)

func()

def bar():

print('i am bar')

use_logging(bar)

邏輯上不難理解， 但是這樣的話，我們每次都要將一個函數(shù)作為參數(shù)傳遞給use_logging函數(shù)。而且這種方式已經(jīng)破壞了原有的代碼邏輯結構，之前執(zhí)行業(yè)務邏輯時，執(zhí)行運行bar()，但是現(xiàn)在不得不改成use_logging(bar)。那么有沒有更好的方式的呢？當然有，答案就是裝飾器。

簡單裝飾器

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args, **kwargs)

return wrapper

def bar():

print('i am bar')

bar = use_logging(bar)

bar()

函數(shù)use_logging就是裝飾器，它把執(zhí)行真正業(yè)務方法的func包裹在函數(shù)里面，看起來像bar被use_logging裝飾了。在這個例子中，函數(shù)進入和退出時 ，被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。

@符號是裝飾器的語法糖，在定義函數(shù)的時候使用，避免再一次賦值操作

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper

@use_logging

def foo():

print("i am foo")

@use_logging

def bar():

print("i am bar")

bar()

如上所示，這樣我們就可以省去bar = use_logging(bar)這一句了，直接調用bar()即可得到想要的結果。如果我們有其他的類似函數(shù)，我們可以繼續(xù)調用裝飾器來修飾函數(shù)，而不用重復修改函數(shù)或者增加新的封裝。這樣，我們就提高了程序的可重復利用性，并增加了程序的可讀性。

裝飾器在Python使用如此方便都要歸因于Python的函數(shù)能像普通的對象一樣能作為參數(shù)傳遞給其他函數(shù)，可以被賦值給其他變量，可以作為返回值，可以被定義在另外一個函數(shù)內。

帶參數(shù)的裝飾器

裝飾器還有更大的靈活性，例如帶參數(shù)的裝飾器：在上面的裝飾器調用中，比如@use_logging，該裝飾器唯一的參數(shù)就是執(zhí)行業(yè)務的函數(shù)。裝飾器的語法允許我們在調用時，提供其它參數(shù)，比如@decorator(a)。這樣，就為裝飾器的編寫和使用提供了更大的靈活性。

def use_logging(level):

def decorator(func):

def wrapper(*args, **kwargs):

if level == "warn":

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper

return decorator

@use_logging(level="warn")

def foo(name='foo'):

print("i am %s" % name)

foo()

上面的use_logging是允許帶參數(shù)的裝飾器。它實際上是對原有裝飾器的一個函數(shù)封裝，并返回一個裝飾器。我們可以將它理解為一個含有參數(shù)的閉包。當我 們使用@use_logging(level="warn")調用的時候，Python能夠發(fā)現(xiàn)這一層的封裝，并把參數(shù)傳遞到裝飾器的環(huán)境中。

類裝飾器

再來看看類裝飾器，相比函數(shù)裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優(yōu)點。使用類裝飾器還可以依靠類內部的\_\_call\_\_方法，當使用 @ 形式將裝飾器附加到函數(shù)上時，就會調用此方法。

class Foo(object):

def __init__(self, func):

self._func = func

def __call__(self):

print ('class decorator runing')

self._func()

print ('class decorator ending')

@Foo

def bar():

print ('bar')

bar()

functools.wraps

使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數(shù)的元信息不見了，比如函數(shù)的docstring、__name__、參數(shù)列表，先看例子：

裝飾器

def logged(func):

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging

函數(shù)

@logged

def f(x):

"""does some math"""

return x + x * x

該函數(shù)完成等價于：

def f(x):

"""does some math"""

return x + x * x

f = logged(f)

不難發(fā)現(xiàn)，函數(shù)f被with_logging取代了，當然它的docstring，__name__就是變成了with_logging函數(shù)的信息了。

print f.__name__ # prints 'with_logging'

print f.__doc__ # prints None

這個問題就比較嚴重的，好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數(shù)的元信息拷貝到裝飾器函數(shù)中，這使得裝飾器函數(shù)也有和原函數(shù)一樣的元信息了。

from functools import wraps

def logged(func):

@wraps(func)

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging

@logged

def f(x):

"""does some math"""

return x + x * x

print f.__name__ # prints 'f'

print f.__doc__ # prints 'does some math'

內置裝飾器

@staticmathod、@classmethod、@property

裝飾器的順序

@a

@b

@c

def f ():

等效于

f = a(b(c(f)))

編輯于 2016-08-09

8 條評論

感謝

分享

收藏

?

沒有幫助

?

舉報

?

作者保留權利

收起

4

贊同

反對，不會顯示你的姓名

許多人選擇編程是因為他們喜歡把時間花在…

4 人贊同

先理解一下閉包的概念吧，之前回答過一個有關閉包和裝飾器的問題，可以參考一下：Python 里函數(shù)里返回一個函數(shù)內部定義的函數(shù)？ - 知乎用戶的回答

顯示全部

先理解一下閉包的概念吧，之前回答過一個有關閉包和裝飾器的問題，可以參考一下：

Python 里函數(shù)里返回一個函數(shù)內部定義的函數(shù)？ - 知乎用戶的回答

發(fā)布于 2014-12-09

2 條評論

感謝

分享

收藏

?

沒有幫助

?

舉報

?

作者保留權利

1

贊同

反對，不會顯示你的姓名

python裝飾器聽了N次也沒印象，讀完這篇你就懂了

裝飾器其實一直是我的一個"老大難"。這個知識點就放在那，但是拖延癥。。。

其實在平常寫寫腳本的過程中，這個知識點你可能用到不多

但在面試的時候，這可是一個高頻問題。

所謂的裝飾器，其實就是通過裝飾器函數(shù)，來修改原函數(shù)的一些功能，使得原函數(shù)不需要修改。

這一句話理解起來可能沒那么輕松，那先來看一個"傻瓜"函數(shù)。

放心，絕對不是"Hello World"！

怎么樣，沒騙你吧？ 哈哈，這個函數(shù)不用運行相信大家都知道輸出結果： "你好，裝飾器" 。

那如果我想讓 hello() 函數(shù)再實現(xiàn)個其他功能，比如多打印一句話。

那么，可以這樣"增強"一下：

運行結果：

很顯然，這個"增強"沒啥作用，但是可以幫助理解裝飾器。

當運行最后的 hello() 函數(shù)時，調用過程是這樣的：

那上述代碼里的 my_decorator() 就是一個裝飾器。

它改變了 hello() 的行為，但是并沒有去真正的改變 hello()函數(shù) 的內部實現(xiàn)。

但是，python一直以"優(yōu)雅"被人追捧，而上述的代碼顯然不夠優(yōu)雅。

所以，想讓上述裝飾器變得優(yōu)雅，可以這樣寫：

這里的 @my_decorator 就相當于舊代碼的 hello = my_decorator(hello) ， @ 符號稱為語法糖。

那如果還有其他函數(shù)也需要加上類似的裝飾，直接在函數(shù)的上方加上 @my_decorator 就可以，大大提高函數(shù)

的重復利用與可讀性。

輸出：

上面的只是一個非常簡單的裝飾器，但是實際場景中，很多函數(shù)都是要帶有參數(shù)的，比如hello(people_name)。

其實也很簡單，要什么我們就給什么唄，直接在對應裝飾器的 wrapper() 上，加上對應的參數(shù)：

輸出：

但是還沒完，這樣雖然簡單，但是隨之而來另一個問題：因為并不是所有函數(shù)參數(shù)都是一樣的，

當其他要使用裝飾器的函數(shù)參數(shù)不止這個一個腫么辦？比如：

沒關系，在python里， *args 和 **kwargs 表示接受任意數(shù)量和類型的參數(shù)，所以我們可以這樣

寫裝飾器里的 wrapper() 函數(shù)：

同時運行下 hello("老王") ，和 hello3("張三", "李四") ，看結果：

上面2種，裝飾器都是接收外來的參數(shù)，其實裝飾器還可以接收自己的參數(shù)。

比如，我加個參數(shù)來控制下裝飾器中打印信息的次數(shù)：

注意，這里 count 裝飾函數(shù)中的2個 return .

運行下，應該會出現(xiàn)3次：

現(xiàn)在多做一步 探索 ，我們來打印下下面例子中的hello()函數(shù)的元信息：

輸出：

這說明了，它不再是以前的那個 hello() 函數(shù)，而是被 wrapper() 函數(shù)取代了。

如果我們需要用到元函數(shù)信息，那怎么保留它呢？這時候可以用內置裝飾器 @functools.wrap 。

運行下：

好記性不如爛筆頭，寫一下理解一下會好很多。

下面還分享類的裝飾器，以及裝飾器所用場景。

Python筆記：Python裝飾器

裝飾器是通過裝飾器函數(shù)修改原函數(shù)的一些功能而不需要修改原函數(shù)，在很多場景可以用到它，比如① 執(zhí)行某個測試用例之前，判斷是否需要登錄或者執(zhí)行某些特定操作；② 統(tǒng)計某個函數(shù)的執(zhí)行時間；③ 判斷輸入合法性等。合理使用裝飾器可以極大地提高程序的可讀性以及運行效率。本文將介紹Python裝飾器的使用方法。

python裝飾器可以定義如下：

輸出：

python解釋器將test_decorator函數(shù)作為參數(shù)傳遞給my_decorator函數(shù)，并指向了內部函數(shù) wrapper()，內部函數(shù) wrapper() 又會調用原函數(shù) test_decorator()，所以decorator()的執(zhí)行會先打印'this is wrapper'，然后打印'hello world'， test_decorator()執(zhí)行完成后，打印 'bye' ，*args和**kwargs，表示接受任意數(shù)量和類型的參數(shù)。

裝飾器 my_decorator() 把真正需要執(zhí)行的函數(shù) test_decorator() 包裹在其中，并且改變了它的行為，但是原函數(shù) test_decorator() 不變。

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

@my_decorator就相當于 decorator = my_decorator(test_decorator) 語句。

內置裝飾器@functools.wrap可用于保留原函數(shù)的元信息（將原函數(shù)的元信息，拷貝到對應的裝飾器函數(shù)里）。先來看看沒有使用functools的情況：

輸出：

從上面的輸出可以看出test_decorator() 函數(shù)被裝飾以后元信息被wrapper() 函數(shù)取代了，可以使用@functools.wrap裝飾器保留原函數(shù)的元信息：

輸出：

裝飾器可以接受自定義參數(shù)。比如定義一個參數(shù)來設置裝飾器內部函數(shù)的執(zhí)行次數(shù)：

輸出：

Python 支持多個裝飾器嵌套：

裝飾的過程：

順序從里到外：

test_decorator('hello world') 執(zhí)行順序和裝飾的過程相反。

輸出：

類也可以作為裝飾器，類裝飾器主要依賴__call__()方法，是python中所有能被調用的對象具有的內置方法（python魔術方法），每當調用一個類的實例時，__call__()就會被執(zhí)行一次。

下面的類裝飾器實現(xiàn)統(tǒng)計函數(shù)執(zhí)行次數(shù)：

輸出：

下面介紹兩種裝飾器使用場景

統(tǒng)計函數(shù)執(zhí)行所花費的時間

輸出：

在使用某些web服務時，需要先判斷用戶是否登錄，如果沒有登錄就跳轉到登錄頁面或者提示用戶登錄：

--THE END--

python裝飾器使用

裝飾器是從英文decorator翻譯過來的，從字面上來看就是對某個東西進行修飾，增強被修飾物的功能，下面我們對裝飾器做下簡單介紹。

一、怎么編寫裝飾器

裝飾器的實現(xiàn)很簡單，本質是一個可調用對象，可以是函數(shù)、方法、對象等，它既可以裝飾函數(shù)也可以裝飾類和方法，為了簡單說明問題，我們實現(xiàn)一個函數(shù)裝飾器，如下代碼：

有了這個裝飾器，我們就可以打印出什么時候開始和結束調用函數(shù)，對于排查函數(shù)的調用鏈非常方便。

二、帶參數(shù)的裝飾器

上面的例子無論什么時候調用sum都會輸出信息，如果我們需要按需輸出信息怎么實現(xiàn)呢，這時就要用到帶參數(shù)的裝飾器了，如下代碼：

對sum使用裝飾器時沒有參數(shù)，這時debug為0，所以調用sum時不會輸出函數(shù)調用相關信息。

對multi使用裝飾器時有參數(shù)，這時debug為1，所以調用multi時會輸出函數(shù)調用相關信息。

三、函數(shù)名字問題

當我們打印被裝飾后的函數(shù)名字時，不知道大家有沒發(fā)現(xiàn)輸出的不是函數(shù)本身的名字，如下代碼會輸出‘wrap’而不是‘sum’：

有時這種表現(xiàn)并不是我們想要的，我們希望被裝飾后的函數(shù)名字還是函數(shù)本身，那要怎么實現(xiàn)呢？很簡單，只需要引入functools.wraps即可，如下代碼就會輸出‘sum’了：

看完后是不是覺得python裝飾器很簡單，只要了解它的本質，怎么寫都行，有好多種玩法呢。

「低門檻 手把手」python 裝飾器(Decorators)原理說明

本文目的是由淺入深地介紹python裝飾器原理

裝飾器(Decorators)是 Python 的一個重要部分

其功能是， 在不修改原函數(shù)(類)定義代碼的情況下，增加新的功能

為了理解和實現(xiàn)裝飾器，我們先引入2個核心操作：

在這個例子中，函數(shù)hi的形參name，默認為'world'

在函數(shù)內部，又定義了另一個函數(shù) howdoyoudo，定義這個函數(shù)時，將形參name作為新函數(shù)的形參name2的默認值。

因此，在函數(shù)內部調用howdoyoudo()時，將以調用hi時的實參為默認值，但也可以給howdoyoudo輸入其他參數(shù)。

上面的例子運行后輸出結果為：

這里新定義的howdoyoudo可以稱作一個“閉包”。不少關于裝飾器的blog都提到了這個概念，但其實沒必要給它取一個多專業(yè)的名字。我們知道閉包是 函數(shù)內的函數(shù) 就可以了

當我們進行 def 的時候，我們在做什么？

這時，hi函數(shù)，打印一個字符串，同時返回一個字符串。

但hi函數(shù)本身也是一個對象，一個可以執(zhí)行的對象。執(zhí)行的方式是hi()。

這里hi和hi()有本質區(qū)別，

hi 代表了這個函數(shù)對象本身

hi() 則是運行了函數(shù)，得到函數(shù)的返回值。

作為對比，可以想象以下代碼

此時也是b存在，可以正常使用。

我們定義2個函數(shù)，分別實現(xiàn)自加1， 自乘2，

再定義一個函數(shù)double_exec，內容是將某個函數(shù)調用2次

在調用double_exec時，可以將函數(shù)作為輸入傳進來

輸出結果就是

7

27

同樣，也可以將函數(shù)作為輸出

輸出結果為

6

10

有了以上兩個核心操作，我們可以嘗試構造裝飾器了。

裝飾器的目的： 在不修改原函數(shù)(類)定義代碼的情況下，增加新的功能

試想一下，現(xiàn)在有一個原函數(shù)

在不修改原函數(shù)定義代碼的情況下，如果想進行函數(shù)內容的添加，可以將這個函數(shù)作為一個整體，添加到這樣的包裹中：

我們定義了一個my_decorator函數(shù)，這個函數(shù)進行了一種操作：

對傳入的f，添加操作(運行前后增加打印)，并把添加操作后的內容連同運行原函數(shù)的內容，一起傳出

這個my_decorator，定義了一種增加前后打印內容的行為

調用my_decorator時，對這個行為進行了操作。

因此，new_function是一個在original_function上增加了前后打印行為的新函數(shù)

這個過程被可以被稱作裝飾。

這里已經(jīng)可以發(fā)現(xiàn)，裝飾器本身對于被裝飾的函數(shù)是什么，是不需要考慮的。裝飾器本身只定義了一種裝飾行為，這個行為是通過裝飾器內部的閉包函數(shù)()進行定義的。

運行裝飾前后的函數(shù)，可以清晰看到裝飾的效果

我們復現(xiàn)一下實際要用裝飾器的情況，我們往往有一種裝飾器，想應用于很多個函數(shù)，比如

此時，如果我們想給3個print函數(shù)都加上裝飾器，需要這么做

實際調用的時候，就需要調用添加裝飾器的函數(shù)名了

當然，也可以賦值給原函數(shù)名

這樣至少不需要管理一系列裝飾前后的函數(shù)。

同時，在不需要進行裝飾的時候，需要把

全部刪掉。

事實上，這樣并不方便，尤其對于更復雜的裝飾器來說

為此，python提供了一種簡寫方式

這個定義print1函數(shù)前的@my_decorator，相當于在定義完print1后，自動直接運行了

不論采用@my_decorator放在新函數(shù)前，還是顯示地重寫print1 = my_decorator(print1)，都會存在一個問題：

裝飾后的函數(shù)，名字改變了(其實不止名字，一系列的索引都改變了)

輸出結果為:

這個現(xiàn)象的原因是，裝飾行為本身，是通過構造了一個新的函數(shù)（例子中是wrap_func函數(shù)）來實現(xiàn)裝飾這個行為的，然后把這個修改后的函數(shù)賦給了原函數(shù)名。

這樣，會導致我們預期的被裝飾函數(shù)的一些系統(tǒng)變量（比如__name__）發(fā)生了變化。

對此，python提供了解決方案：

經(jīng)過這個行為后，被裝飾函數(shù)的系統(tǒng)變量問題被解決了

輸出結果為

剛才的例子都比較簡單，被裝飾的函數(shù)是沒有參數(shù)的。如果被裝飾的函數(shù)有參數(shù)，只需要在定義裝飾行為時（事實上，這個才更通用），增加(*args, **kwargs)描述即可

之前的描述中可以感受到，對于例子中的裝飾行為(前后加打印)，函數(shù)被裝飾后，本質上是調用了新的裝飾函數(shù)wrap_func。

因此，如果原函數(shù)需要有輸入?yún)?shù)傳遞，只需要在wrap_func（或其他任意名字的裝飾函數(shù)）定義時，也增加參數(shù)輸入(*args, **kwargs)，并將這些參數(shù)，原封不動地傳給待裝飾函數(shù)f。

這種定義裝飾行為的方式更具有普遍性，忘記之前的定義方式吧

我們試一下

輸出

這里需要注意的是，如果按照以下的方式定義裝飾器

那么以下語句將不會執(zhí)行

因為裝飾后實際的函數(shù)wrap_func(雖然名字被改成了原函數(shù)，系統(tǒng)參數(shù)也改成了原函數(shù))，運行到return f(*args, **kwargs) 的時候已經(jīng)結束了

因為裝飾器my_decorator本身也是可以輸入的，因此，只需要在定義裝飾器時，增加參數(shù)，并在后續(xù)函數(shù)中使用就可以了，比如

此時裝飾器已經(jīng)可以有輸入?yún)?shù)了

輸出

你可能發(fā)現(xiàn)，為什么不用簡寫版的方法了

因為以上代碼會報錯！！

究其原因，雖然

等價于

但是，

并不等價于

這本身和@語法有關，使用@my_decorator時，是系統(tǒng)在應用一個以單個函數(shù)作為參數(shù)的閉包函數(shù)。即，@是不能帶參數(shù)的。

但是你應該發(fā)現(xiàn)了，之前的@wraps(f)不是帶參數(shù)了嗎？請仔細觀察以下代碼

通過一層嵌套，my_decorator_with_parma本質上是返回了一個參數(shù)僅為一個函數(shù)的函數(shù)(my_decorator)，但因為my_decorator對my_decorator_with_parma來說是一個閉包，my_decorator_with_parma是可以帶參數(shù)的。（這句話真繞）

通過以上的定義，我們再來看

可以這么理解，my_decorator_with_parma(msg='yusheng')的結果是原來的my_decorator函數(shù)，同時，因為my_decorator_with_parma可以傳參，參數(shù)實際上是參與了my_decorator的（因為my_decorator對my_decorator_with_parma是閉包）， my_decorator_with_parma(msg='yusheng') 全等于 一個有參數(shù)參加的my_decorator

因此，以上代碼等價于有參數(shù)msg傳遞的

比較繞，需要理解一下，或者干脆強記這種范式：

以上范式包含函數(shù)的輸入輸出、裝飾器的輸入，可以應對大部分情況了。

實驗一下：

輸出

以上是一個log裝飾器，利用datetime統(tǒng)計了函數(shù)的耗時，

并且，裝飾器可以進行輸出文件操作，如果給出了文件路徑，則輸出文件，否則就打印。

利用這個裝飾器，可以靈活地進行耗時統(tǒng)計

不設置輸出文件地址，則打印。運行結果為：

也可以輸出到文件

輸出結果為

同時在當前目錄生成了一個test.log 文件，內容為：

以上的裝飾器都是以函數(shù)形式出現(xiàn)的，但我們可以稍做改寫，將裝飾器以類的形式實現(xiàn)。

這個裝飾器類Log 上個例子里的裝飾器函數(shù)log功能是一樣的，同時，這個裝飾器類還可以作為基類被其他繼承，進一步增加功能。

原文

網(wǎng)站標題：關于Python裝飾函數(shù)詳解的信息
文章轉載：http://vcdvsql.cn/article26/hchijg.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站內鏈、標簽優(yōu)化、網(wǎng)站導航、微信小程序、全網(wǎng)營銷推廣、App設計

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)