自動化工具 Python 裝飾器的進化史

1、史前故事

先看一個簡單例子，實際可能會複雜不少：

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函數，這就破壞了原有的代碼結構，爲了支持日誌功能，原有代碼須要大幅修改，那麼有沒有更好的方式的呢？固然有，答案就是裝飾器。

2、開天闢地

一個簡單的裝飾器

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()

以上也是裝飾器的原理！！！

3、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函數或類，它可讓其餘函數或類在不須要作任何代碼修改的前提下增長額外的功能，裝飾器的返回值也是一個函數/類對象。
它常常用於有切面需求的場景，好比：插入日誌、性能測試、事務處理、緩存、權限校驗等場景，裝飾器是解決這類問題的絕佳設計。
有了裝飾器，咱們就能夠抽離出大量與函數功能自己無關的代碼到裝飾器中並繼續重用。
簡單來講：裝飾器的做用就是讓已經存在的對象添加額外的功能。

4、多元化百家爭鳴

一、帶參數的裝飾器

裝飾器的語法容許咱們在調用時，提供其它參數，好比@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()

二、讓裝飾器同時支持帶參數或不帶參數

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()

如上所示，參數有兩種類型，一種是字符串，另外一種是可調用的函數類型。所以，經過對參數類型的判斷便可實現支持帶參數和不帶參數的兩種狀況。

三、類裝飾器

裝飾器不只能夠是函數，還能夠是類，相比函數裝飾器，類裝飾器具備靈活度大、高內聚、封裝性等優勢。使用類裝飾器主要依靠類的call方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。

（1）示例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）示例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）示例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

四、裝飾函數 -> 裝飾類

（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

5、上古神器

一、@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!

二、@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)

三、@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)) # 輸出被裝飾函數的簽名信息

四、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)))

即：它的執行順序是從裏到外，最早調用最裏層，最後調用最外層的裝飾器。