本文目錄一覽：
python裝飾器是什麼意思
裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對於好多小白來講，這個功能 有點繞，自學時直接繞過去了，然後面試問到了就掛了，因為裝飾器是程序開發的基礎知識，這個都 不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。
1、先明白這段代碼
#### 第一波 ####
def foo():
print ‘foo’
foo #表示是函數
foo() #表示執行foo函數
#### 第二波 ####
def foo():
print ‘foo’
foo = lambda x: x + 1
foo() # 執行下面的lambda表達式，而不再是原來的foo函數，因為函數 foo 被重新定義了
2、需求來了
初創公司有N個業務部門，1個基礎平台部門，基礎平台負責提供底層的功能，如：數據庫操作、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平台提供的功能即可。如下：
############### 基礎平台提供的功能如下 ###############
def f1():
print ‘f1’
def f2():
print ‘f2’
def f3():
print ‘f3’
def f4():
print ‘f4’
############### 業務部門A 調用基礎平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 業務部門B 調用基礎平台提供的功能 ###############
f1()
f2()
f3()
f4()
目前公司有條不紊的進行着，但是，以前基礎平台的開發人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平台的提供的功能可以被任何人使用。現在需要對基礎平台的所有功能進行重構，為平台提供的所有功能添加驗證機制，即：執行功能前，先進行驗證。
老大把工作交給 Low B，他是這麼做的：
跟每個業務部門交涉，每個業務部門自己寫代碼，調用基礎平台的功能之前先驗證。誒，這樣一來基礎平台就不需要做任何修改了。
當天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’
############### 業務部門不變 ###############
### 業務部門A 調用基礎平台提供的功能###
f1()
f2()
f3()
f4()
### 業務部門B 調用基礎平台提供的功能 ###
f1()
f2()
f3()
f4()
過了一周 Low BB 被開除了…
老大把工作交給 Low BBB，他是這麼做的：
只對基礎平台的代碼進行重構，其他業務部門無需做任何修改
############### 基礎平台提供的功能如下 ###############
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 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：
老大說：
寫代碼要遵循開發封閉原則，雖然在這個原則是用的面向對象開發，但是也適用於函數式編程，簡單來說，它規定已經實現的功能代碼不允許被修改，但可以被擴展，即：
封閉：已實現的功能代碼塊
開放：對擴展開發
如果將開放封閉原則應用在上述需求中，那麼就不允許在函數 f1 、f2、f3、f4的內部進行修改代碼，老闆就給了Low BBB一個實現方案：
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’
對於上述代碼，也是僅僅對基礎平台的代碼進行修改，就可以實現在其他人調用函數 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。
Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什麼呢？
老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：
單獨以f1為例：
def w1(func):
def inner():
# 驗證1
# 驗證2
# 驗證3
return func()
return inner
@w1
def f1():
print ‘f1’
當寫完這段代碼後（函數未被執行、未被執行、未被執行），python解釋器就會從上到下解釋代碼，步驟如下：
def w1(func): ==將w1函數加載到內存
@w1
沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數在沒有被調用之前其內部代碼不會被執行。
從表面上看解釋器着實會執行這兩句，但是 @w1 這一句代碼里卻有大文章，@函數名 是python的一種語法糖。
如上例@w1內部會執行一下操作：
執行w1函數，並將 @w1 下面的 函數 作為w1函數的參數，即：@w1 等價於 w1(f1)
所以，內部就會去執行：
def inner:
#驗證
return f1() # func是參數，此時 func 等於 f1
return inner # 返回的 inner，inner代表的是函數，非執行函數
其實就是將原來的 f1 函數塞進另外一個函數中
將執行完的 w1 函數返回值賦值給@w1下面的函數的函數名
w1函數的返回值是：
def inner:
#驗證
return 原來f1() # 此處的 f1 表示原來的f1函數
然後，將此返回值再重新賦值給 f1，即：
新f1 = def inner:
#驗證
return 原來f1()
所以，以後業務部門想要執行 f1 函數時，就會執行 新f1 函數，在 新f1 函數內部先執行驗證，再執行原來的f1函數，然後將 原來f1 函數的返回值 返回給了業務調用者。
如此一來， 即執行了驗證的功能，又執行了原來f1函數的內容，並將原f1函數返回值 返回給業務調用着
Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！
先把上述流程看懂，之後還會繼續更新…
3、問答時間
問題：被裝飾的函數如果有參數呢？
#一個參數
def w1(func):
def inner(arg):
# 驗證1
# 驗證2
# 驗證3
return func(arg)
return inner
@w1
def f1(arg):
print ‘f1’
#兩個參數
def w1(func):
def inner(arg1,arg2):
# 驗證1
# 驗證2
# 驗證3
return func(arg1,arg2)
return inner
@w1
def f1(arg1,arg2):
print ‘f1’
#三個參數
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個參數的函數的裝飾器？
def w1(func):
def inner(*args,**kwargs):
# 驗證1
# 驗證2
# 驗證3
return func(*args,**kwargs)
return inner
@w1
def f1(arg1,arg2,arg3):
print ‘f1’
問題：一個函數可以被多個裝飾器裝飾嗎？
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筆記：Python裝飾器
裝飾器是通過裝飾器函數修改原函數的一些功能而不需要修改原函數，在很多場景可以用到它，比如① 執行某個測試用例之前，判斷是否需要登錄或者執行某些特定操作；② 統計某個函數的執行時間；③ 判斷輸入合法性等。合理使用裝飾器可以極大地提高程序的可讀性以及運行效率。本文將介紹Python裝飾器的使用方法。
python裝飾器可以定義如下：
輸出：
python解釋器將test_decorator函數作為參數傳遞給my_decorator函數，並指向了內部函數 wrapper()，內部函數 wrapper() 又會調用原函數 test_decorator()，所以decorator()的執行會先打印’this is wrapper’，然後打印’hello world’， test_decorator()執行完成後，打印 ‘bye’ ，*args和**kwargs，表示接受任意數量和類型的參數。
裝飾器 my_decorator() 把真正需要執行的函數 test_decorator() 包裹在其中，並且改變了它的行為，但是原函數 test_decorator() 不變。
一般使用如下形式使用裝飾器：
@my_decorator就相當於 decorator = my_decorator(test_decorator) 語句。
內置裝飾器@functools.wrap可用於保留原函數的元信息（將原函數的元信息，拷貝到對應的裝飾器函數里）。先來看看沒有使用functools的情況：
輸出：
從上面的輸出可以看出test_decorator() 函數被裝飾以後元信息被wrapper() 函數取代了，可以使用@functools.wrap裝飾器保留原函數的元信息：
輸出：
裝飾器可以接受自定義參數。比如定義一個參數來設置裝飾器內部函數的執行次數：
輸出：
Python 支持多個裝飾器嵌套：
裝飾的過程：
順序從裡到外：
test_decorator(‘hello world’) 執行順序和裝飾的過程相反。
輸出：
類也可以作為裝飾器，類裝飾器主要依賴__call__()方法，是python中所有能被調用的對象具有的內置方法（python魔術方法），每當調用一個類的實例時，__call__()就會被執行一次。
下面的類裝飾器實現統計函數執行次數：
輸出：
下面介紹兩種裝飾器使用場景
統計函數執行所花費的時間
輸出：
在使用某些web服務時，需要先判斷用戶是否登錄，如果沒有登錄就跳轉到登錄頁面或者提示用戶登錄：
–THE END–
「低門檻 手把手」python 裝飾器(Decorators)原理說明
本文目的是由淺入深地介紹python裝飾器原理
裝飾器(Decorators)是 Python 的一個重要部分
其功能是， 在不修改原函數(類)定義代碼的情況下，增加新的功能
為了理解和實現裝飾器，我們先引入2個核心操作：
在這個例子中，函數hi的形參name，默認為’world’
在函數內部，又定義了另一個函數 howdoyoudo，定義這個函數時，將形參name作為新函數的形參name2的默認值。
因此，在函數內部調用howdoyoudo()時，將以調用hi時的實參為默認值，但也可以給howdoyoudo輸入其他參數。
上面的例子運行後輸出結果為：
這裡新定義的howdoyoudo可以稱作一個“閉包”。不少關於裝飾器的blog都提到了這個概念，但其實沒必要給它取一個多專業的名字。我們知道閉包是 函數內的函數 就可以了
當我們進行 def 的時候，我們在做什麼？
這時，hi函數，打印一個字符串，同時返回一個字符串。
但hi函數本身也是一個對象，一個可以執行的對象。執行的方式是hi()。
這裡hi和hi()有本質區別，
hi 代表了這個函數對象本身
hi() 則是運行了函數，得到函數的返回值。
作為對比，可以想象以下代碼
此時也是b存在，可以正常使用。
我們定義2個函數，分別實現自加1， 自乘2，
再定義一個函數double_exec，內容是將某個函數調用2次
在調用double_exec時，可以將函數作為輸入傳進來
輸出結果就是
7
27
同樣，也可以將函數作為輸出
輸出結果為
6
10
有了以上兩個核心操作，我們可以嘗試構造裝飾器了。
裝飾器的目的： 在不修改原函數(類)定義代碼的情況下，增加新的功能
試想一下，現在有一個原函數
在不修改原函數定義代碼的情況下，如果想進行函數內容的添加，可以將這個函數作為一個整體，添加到這樣的包裹中：
我們定義了一個my_decorator函數，這個函數進行了一種操作：
對傳入的f，添加操作(運行前後增加打印)，並把添加操作後的內容連同運行原函數的內容，一起傳出
這個my_decorator，定義了一種增加前後打印內容的行為
調用my_decorator時，對這個行為進行了操作。
因此，new_function是一個在original_function上增加了前後打印行為的新函數
這個過程被可以被稱作裝飾。
這裡已經可以發現，裝飾器本身對於被裝飾的函數是什麼，是不需要考慮的。裝飾器本身只定義了一種裝飾行為，這個行為是通過裝飾器內部的閉包函數()進行定義的。
運行裝飾前後的函數，可以清晰看到裝飾的效果
我們復現一下實際要用裝飾器的情況，我們往往有一種裝飾器，想應用於很多個函數，比如
此時，如果我們想給3個print函數都加上裝飾器，需要這麼做
實際調用的時候，就需要調用添加裝飾器的函數名了
當然，也可以賦值給原函數名
這樣至少不需要管理一系列裝飾前後的函數。
同時，在不需要進行裝飾的時候，需要把
全部刪掉。
事實上，這樣並不方便，尤其對於更複雜的裝飾器來說
為此，python提供了一種簡寫方式
這個定義print1函數前的@my_decorator，相當於在定義完print1後，自動直接運行了
不論採用@my_decorator放在新函數前，還是顯示地重寫print1 = my_decorator(print1)，都會存在一個問題：
裝飾後的函數，名字改變了(其實不止名字，一系列的索引都改變了)
輸出結果為:
這個現象的原因是，裝飾行為本身，是通過構造了一個新的函數（例子中是wrap_func函數）來實現裝飾這個行為的，然後把這個修改後的函數賦給了原函數名。
這樣，會導致我們預期的被裝飾函數的一些系統變量（比如__name__）發生了變化。
對此，python提供了解決方案：
經過這個行為後，被裝飾函數的系統變量問題被解決了
輸出結果為
剛才的例子都比較簡單，被裝飾的函數是沒有參數的。如果被裝飾的函數有參數，只需要在定義裝飾行為時（事實上，這個才更通用），增加(*args, **kwargs)描述即可
之前的描述中可以感受到，對於例子中的裝飾行為(前後加打印)，函數被裝飾後，本質上是調用了新的裝飾函數wrap_func。
因此，如果原函數需要有輸入參數傳遞，只需要在wrap_func（或其他任意名字的裝飾函數）定義時，也增加參數輸入(*args, **kwargs)，並將這些參數，原封不動地傳給待裝飾函數f。
這種定義裝飾行為的方式更具有普遍性，忘記之前的定義方式吧
我們試一下
輸出
這裡需要注意的是，如果按照以下的方式定義裝飾器
那麼以下語句將不會執行
因為裝飾後實際的函數wrap_func(雖然名字被改成了原函數，系統參數也改成了原函數)，運行到return f(*args, **kwargs) 的時候已經結束了
因為裝飾器my_decorator本身也是可以輸入的，因此，只需要在定義裝飾器時，增加參數，並在後續函數中使用就可以了，比如
此時裝飾器已經可以有輸入參數了
輸出
你可能發現，為什麼不用簡寫版的方法了
因為以上代碼會報錯！！
究其原因，雖然
等價於
但是，
並不等價於
這本身和@語法有關，使用@my_decorator時，是系統在應用一個以單個函數作為參數的閉包函數。即，@是不能帶參數的。
但是你應該發現了，之前的@wraps(f)不是帶參數了嗎？請仔細觀察以下代碼
通過一層嵌套，my_decorator_with_parma本質上是返回了一個參數僅為一個函數的函數(my_decorator)，但因為my_decorator對my_decorator_with_parma來說是一個閉包，my_decorator_with_parma是可以帶參數的。（這句話真繞）
通過以上的定義，我們再來看
可以這麼理解，my_decorator_with_parma(msg=’yusheng’)的結果是原來的my_decorator函數，同時，因為my_decorator_with_parma可以傳參，參數實際上是參與了my_decorator的（因為my_decorator對my_decorator_with_parma是閉包）， my_decorator_with_parma(msg=’yusheng’) 全等於 一個有參數參加的my_decorator
因此，以上代碼等價於有參數msg傳遞的
比較繞，需要理解一下，或者乾脆強記這種範式：
以上範式包含函數的輸入輸出、裝飾器的輸入，可以應對大部分情況了。
實驗一下：
輸出
以上是一個log裝飾器，利用datetime統計了函數的耗時，
並且，裝飾器可以進行輸出文件操作，如果給出了文件路徑，則輸出文件，否則就打印。
利用這個裝飾器，可以靈活地進行耗時統計
不設置輸出文件地址，則打印。運行結果為：
也可以輸出到文件
輸出結果為
同時在當前目錄生成了一個test.log 文件，內容為：
以上的裝飾器都是以函數形式出現的，但我們可以稍做改寫，將裝飾器以類的形式實現。
這個裝飾器類Log 上個例子里的裝飾器函數log功能是一樣的，同時，這個裝飾器類還可以作為基類被其他繼承，進一步增加功能。
原文
如何理解Python裝飾器
裝飾器本質上是一個Python函數，它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數對象。它經常用於有切面需求的場景，比如：插入日誌、性能測試、事務處理、緩存、權限校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外的功能。
先來看一個簡單例子：
def foo():
print(‘i am foo’)
現在有一個新的需求，希望可以記錄下函數的執行日誌，於是在代碼中添加日誌代碼：
def foo():
print(‘i am foo’)
logging.info(“foo is running”)
bar()、bar2()也有類似的需求，怎麼做？再寫一個logging在bar函數里？這樣就造成大量雷同的代碼，為了減少重複寫代碼，我們可以這樣做，重新定義一個函數：專門處理日誌 ，日誌處理完之後再執行真正的業務代碼
def use_logging(func):
logging.warn(“%s is running” % func.__name__)
func()
def bar():
print(‘i am bar’)
use_logging(bar)
邏輯上不難理解，
但是這樣的話，我們每次都要將一個函數作為參數傳遞給use_logging函數。而且這種方式已經破壞了原有的代碼邏輯結構，之前執行業務邏輯時，執行運行bar()，但是現在不得不改成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()
函數use_logging就是裝飾器，它把執行真正業務方法的func包裹在函數裡面，看起來像bar被use_logging裝飾了。在這個例子中，函數進入和退出時
，被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。
@符號是裝飾器的語法糖，在定義函數的時候使用，避免再一次賦值操作
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()即可得到想要的結果。如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不用重複修改函數或者增加新的封裝。這樣，我們就提高了程序的可重複利用性，並增加了程序的可讀性。
裝飾器在Python使用如此方便都要歸因於Python的函數能像普通的對象一樣能作為參數傳遞給其他函數，可以被賦值給其他變量，可以作為返回值，可以被定義在另外一個函數內。
帶參數的裝飾器
裝飾器還有更大的靈活性，例如帶參數的裝飾器：在上面的裝飾器調用中，比如@use_logging，該裝飾器唯一的參數就是執行業務的函數。裝飾器的語法允許我們在調用時，提供其它參數，比如@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是允許帶參數的裝飾器。它實際上是對原有裝飾器的一個函數封裝，並返回一個裝飾器。我們可以將它理解為一個含有參數的閉包。當我
們使用@use_logging(level=”warn”)調用的時候，Python能夠發現這一層的封裝，並把參數傳遞到裝飾器的環境中。
類裝飾器
再來看看類裝飾器，相比函數裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器還可以依靠類內部的\_\_call\_\_方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。
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
使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、__name__、參數列表，先看例子：
裝飾器
def logged(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
該函數完成等價於：
def f(x):
“””does some math”””
return x + x * x
f = logged(f)
不難發現，函數f被with_logging取代了，當然它的docstring，__name__就是變成了with_logging函數的信息了。
print f.__name__ # prints ‘with_logging’
print f.__doc__ # prints None
這個問題就比較嚴重的，好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器函數中，這使得裝飾器函數也有和原函數一樣的元信息了。
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)))
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/288652.html
微信掃一掃 
支付寶掃一掃 