一、史前故事
先看一個簡單例子，實際可能會複雜很多：
def today():
print('2018-05-25')
複製程式碼現在有一個新的需求，希望可以記錄下函式的執行日誌，於是在程式碼中新增日誌程式碼：
def today():
print('2018-05-25')
logging.info('today is running...')
複製程式碼如果函式 yesterday()、tomorrow() 也有類似的需求，怎麼做？再寫一個 logging 在yesterday函式裡？這樣就造成大量雷同的程式碼，為了減少重複寫程式碼，我們可以這樣做，重新定義一個新的函式：專門處理日誌 ，日誌處理完之後再執行真正的業務程式碼
def logging_tool(func):
logging.info('%s is running...' % func.__name__)
func()
def today():
print('2018-05-25')
logging_tool(today)
複製程式碼這樣做邏輯上是沒問題的，功能是實現了，但是我們呼叫的時候不再是呼叫真正的業務邏輯today函式，而是換成了logging_tool函式，這就破壞了原有的程式碼結構，為了支援日誌功能，原有程式碼需要大幅修改，那麼有沒有更好的方式的呢？當然有，答案就是裝飾器。
二、開天闢地
一個簡單的裝飾器
def logging_tool(func):
def wrapper(*arg, **kwargs):
logging.info('%s is running...' % func.__name__)
func() # 把today當作引數傳遞進來，執行func()就相當於執行today()
return wrapper
def today():
print('2018-05-25')
today = logging_tool(today) # 因為裝飾器logging_tool(today)返回函式物件wrapper，故這條語句相當於today=wrapper
today() # 執行today()就相當於執行wrapper()
複製程式碼以上也是裝飾器的原理！！！
三、Pythonic世界的初探
@語法糖 接觸 Python 有一段時間的話，對 @ 符號一定不陌生了，沒錯 @ 符號就是裝飾器的語法糖，它放在函式開始定義的地方，這樣就可以省略最後一步再次賦值的操作
def logging_tool(func):
def wrapper(*arg, **kwargs):
logging.info('%s is running...' % func.__name__)
func() # 把today當作引數傳遞進來，執行func()就相當於執行today()
return wrapper
@logging_tool
def today():
print('2018-05-25')
today()
複製程式碼有了 @ ，我們就可以省去today = logging_tool(today)這一句了，直接呼叫 today() 即可得到想要的結果。 不需要對today() 函式做任何修改，只需在定義的地方加上裝飾器，呼叫的時候還是和以前一樣。 如果我們有其他的類似函式，可以繼續呼叫裝飾器來修飾函式，而不用重複修改函式或者增加新的封裝。這樣，提高程式可重複利用性，並增加程式的可讀性。
裝飾器在 Python 使用之所以如此方便，歸因於Python函式能像普通的物件一樣能作為引數傳遞給其他函式，可以被賦值給其他變數，可以作為返回值，可以被定義在另外一個函式內。
裝飾器本質上是一個Python函式或類，它可以讓其他函式或類在不需要做任何程式碼修改的前提下增加額外的功能，裝飾器的返回值也是一個函式/類物件。 它經常用於有切面需求的場景，比如：插入日誌、效能測試、事務處理、快取、許可權校驗等場景，裝飾器是解決這類問題的絕佳設計。 有了裝飾器，我們就可以抽離出大量與函式功能本身無關的程式碼到裝飾器中並繼續重用。 簡單來說：裝飾器的作用就是讓已經存在的物件新增額外的功能。
四、多元化百家爭鳴
1、帶引數的裝飾器
裝飾器的語法允許我們在呼叫時，提供其它引數，比如@decorator(condition)。為裝飾器的編寫和使用提供了更大的靈活性。比如，我們可以在裝飾器中指定日誌的等級，因為不同業務函式可能需要不同的日誌級別。
def logging_tool(level):
def decorator(func):
def wrapper(*arg, **kwargs):
if level == 'error':
logging.error('%s is running...' % func.__name__)
elif level == 'warn':
logging.warn('%s is running...' % func.__name__)
else:
logging.info('%s is running...' % func.__name__)
func()
return wrapper
return decorator
@logging_tool(level='warn')
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name)
today()
複製程式碼2、讓裝飾器同時支援帶引數或不帶引數
def new_logging_tool(obj):
if isinstanc(obj, str): # 帶引數的情況，引數型別為str
def decorator(func):
@functools.wraps(func)
def wrapper(*arg, **kwargs):
if obj == 'error':
logging.error('%s is running...' % func.__name__)
elif obj == 'warn':
logging.warn('%s is running...' % func.__name__)
else:
logging.info('%s is running...' % func.__name__)
func()
return wrapper
return decorator
else: # 不帶引數的情況，引數型別為函式型別，即被裝飾的函式
@functools.wraps(obj)
def wrapper(*args, **kwargs):
logging.info('%s is running...' % obj.__name__)
obj()
return wrapper
@new_logging_tool
def yesterday():
print('2018-05-24')
yesterday()
@new_logging_tool('warn')
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name)
today()
複製程式碼如上所示，引數有兩種型別，一種是字串，另一種是可呼叫的函式型別。因此，通過對引數型別的判斷即可實現支援帶引數和不帶引數的兩種情況。
3、類裝飾器
裝飾器不僅可以是函式，還可以是類，相比函式裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器主要依靠類的__call__方法，當使用 @ 形式將裝飾器附加到函式上時，就會呼叫此方法。
（1）示例一、被裝飾函式不帶引數
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()
複製程式碼（2）示例二、被裝飾函式帶引數
class Counter:
def __init__(self, func):
self.func = func
self.count = 0 # 記錄函式被呼叫的次數
def __call__(self, *args, **kwargs):
self.count += 1
return self.func(*args, **kwargs)
@Counter
def today(name='devin'):
print('Hello, %s! Today is 208-05-25' % name) # 被裝飾的函式帶引數的情況
for i in range(10):
today()
print(today.count) # 10
複製程式碼（3）示例三、不依賴初始化函式，單獨使用__call__函式實現（體現類裝飾器靈活性大、高內聚、封裝性高的特點） 實現當一些重要函式執行時，列印日誌到一個檔案中，同時傳送一個通知給使用者
class LogTool(object):
def __init__(self, logfile='out.log'):
self.logfile = logfile # 指定日誌記錄檔案
def __call__(self, func): # __call__作為裝飾器函式
@functools.wraps(func)
def wrapper(*args, **kwargs):
log_string = func.__name__ + " was called"
print(log_string) # 輸出日誌
with open(self.logfile, 'a') as fw:
fw.write(log_string + '\n') # 儲存日誌
self.notify() # 傳送通知
return func(*args, **kwargs)
return wrapper
# 在類中實現通知功能的封裝
def notify(self):
pass
@LogTool() # 單獨使用__call__函式實現時，別忘了新增括號，進行類的初始化
def bill_func():
pass
複製程式碼進一步擴充套件，給LogTool建立子類，來新增email的功能：
class EmailTool(LogTool):
"""
LogTool的子類，實現email通知功能，在函式呼叫時傳送email給使用者
"""
def __init__(self, email='admin@myproject.com', *args, **kwargs):
self.email = email
super(EmailTool, self).__init__(*args, **kwargs)
# 覆蓋父類的通知功能，實現傳送一封email到self.email
def notify(self):
pass
@EmailTool()
def bill_func():
pass
複製程式碼4、裝飾函式 -> 裝飾類
（1）函式層面的裝飾器很常見，以一個函式作為輸入，返回一個新的函式； （2）類層面的裝飾其實也類似，已一個類作為輸入，返回一個新的類；
例如：給一個已有的類新增長度屬性和getter、setter方法
def Length(cls):
class NewClass(cls):
@property
def length(self):
if hasattr(self, '__len__'):
self._length = len(self)
return self._length
@length.setter
def length(self, value):
self._length = value
return NewClass
@Length
class Tool(object):
pass
t = Tool()
t.length = 10
print(t.length) # 10
複製程式碼五、上古神器
1、@property -> getter/setter方法
示例：給一個Student新增score屬性的getter、setter方法
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer')
if value < 0 or value > 100:
raise ValueError('score must between 0~100!')
self._score = value
s = Student()
s.core = 60
print('s.score = ', s.score)
s.score = 999 # ValueError: score must between 0~100!
複製程式碼2、@classmethod、@staticmethod
（1）@classmethod 類方法：定義備選構造器，第一個引數是類本身（引數名不限制，一般用cls） （2）@staticmethod 靜態方法：跟類關係緊密的函式
簡單原理示例：
class A(object):
@classmethod
def method(cls):
pass
複製程式碼等價於
class A(object):
def method(cls):
pass
method = classmethod(method)
複製程式碼3、@functools.wraps
裝飾器極大地複用了程式碼，但它有一個缺點：因為返回的是巢狀的函式物件wrapper，不是原函式，導致原函式的元資訊丟失，比如函式的docstring、name、引數列表等資訊。不過呢，辦法總比困難多，我們可以通過@functools.wraps將原函式的元資訊拷貝到裝飾器裡面的func函式中，使得裝飾器裡面的func和原函式有一樣的元資訊。
def timethis(func):
"""
Decorator that reports the execution time.
"""
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(func.__name__, time.time() - start)
return result
return wrapper
@timethis
def countdown(n: int):
"""Counts down"""
while n > 0:
n -= 1
countdown(10000000) # 1.3556335
print(countdown.__name__, ' doc: ', countdown.__doc__, ' annotations: ', countdown.__annotations__)
複製程式碼@functools.wraps讓我們可以通過屬性__wrapped__直接訪問被裝飾的函式，同時讓被裝飾函式正確暴露底層的引數簽名資訊
countdown.__wrapped__(1000) # 訪問被裝飾的函式
print(inspect.signature(countdown)) # 輸出被裝飾函式的簽名資訊
複製程式碼4、Easter egg
（1） 定義一個接受引數的包裝器
@decorator(x, y, z)
def func(a, b):
pass
複製程式碼等價於
func = decorator(x, y, z)(func)
複製程式碼即：decorator(x, y, z)的返回結果必須是一個可呼叫的物件，它接受一個函式作為引數幷包裝它。
（2）一個函式可以同時定義多個裝飾器，比如：
@a
@b
@c
def f():
pass
複製程式碼等價於
f = a(b(c(f)))
複製程式碼即：它的執行順序是從裡到外，最先呼叫最裡層，最後呼叫最外層的裝飾器。
六、最後
對於Python裝飾器，除了以上列舉的示例，還有很多很多神奇的用法，同時裝飾器也只是Pythonic中的冰山一角，這裡僅當拋磚引玉，更多hacker用法，少年，盡情愉快地探索吧......
（更多精彩內容，敬請關注：DevinBlog）
參考：