裝飾器的原理就是利用《閉包函數》來實現，閉包函數的原理就是包含內層函數的return和外層環境變量：
裝飾器： 裝飾器本質上是一個Python函數，其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值（return）也是一個函數對象。它經常用於有切面需求的場景，比如：插入日志、性能測試、事務處理、緩存、權限校驗等場景。
|
1
2
3
4
5
6
7
8
9
|
先來看一個簡單例子：
def
foo():
print
(
'i am foo'
)
現在有一個新的需求，希望可以記錄下函數的執行日志，於是在代碼中添加日志代碼：
def
foo():
print
(
'i am foo'
)
logging.info(
"foo is running"
)
|
bar()、bar2()也有類似的需求，怎么做？再寫一個logging在bar函數里？這樣就造成大量雷同的代碼，為了減少重復寫代碼，我們可以這樣做，重新定義一個函數：專門處理日志 ，日志處理完之后再執行真正的業務代碼
|
1
2
3
4
5
6
7
8
|
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)。那么有沒有更好的方式的呢？當然有，答案就是裝飾器。
簡單裝飾器
函 數use_logging就是裝飾器，它把執行真正業務方法的func包裹在函數里面，看起來像bar被use_logging裝飾了。在這個例子中，函 數進入和退出時 ，被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。
@符號是裝飾器的語法糖，在定義函數的時候使用，避免再一次賦值操作
如 上所示，這樣我們就可以省去bar = use_logging(bar)這一句了，直接調用bar()即可得到想要的結果。如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不 用重復修改函數或者增加新的封裝。這樣，我們就提高了程序的可重復利用性，並增加了程序的可讀性。
裝飾器在Python使用如此方便都要歸因於Python的函數能像普通的對象一樣能作為參數傳遞給其他函數，可以被賦值給其他變量，可以作為返回值，可以被定義在另外一個函數內。
帶參數的裝飾器
裝飾器還有更大的靈活性，例如帶參數的裝飾器：在上面的裝飾器調用中，比如 @use_logging，該裝飾器唯一的參數就是執行業務的函數。裝飾器的語法允許我們在調用時，提供其它參數，比如@decorator(a)。這 樣，就為裝飾器的編寫和使用提供了更大的靈活性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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__方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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()
|
使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、__name__、參數列表，先看例子：
裝飾器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器函數中，這使得裝飾器函數也有和原函數一樣的元信息了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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)))
