Python裝飾器與面向切面編程

今天來討論一下裝飾器。裝飾器是一個很著名的設計模式，常常被用於有切面需求的場景，較爲經典的有插入日誌、性能測試、事務處理等。裝飾器是解決這類問題的絕佳設計，有了裝飾器，咱們就能夠抽離出大量函數中與函數功能自己無關的雷同代碼並繼續重用。歸納的講，裝飾器的做用就是爲已經存在的對象添加額外的功能。

1. 裝飾器入門

1.1. 需求是怎麼來的？

裝飾器的定義非常抽象，咱們來看一個小例子。

1 2 3 4

def foo():     print 'in foo()'   foo()

這是一個很無聊的函數沒錯。可是忽然有一個更無聊的人，咱們稱呼他爲B君，說我想看看執行這個函數用了多長時間，好吧，那麼咱們能夠這樣作：

1 2 3 4 5 6 7 8

import time def foo():     start= time.clock()     print 'in foo()'     end= time.clock()     print 'used:', end- start   foo()

很好，功能看起來無懈可擊。但是蛋疼的B君此刻忽然不想看這個函數了，他對另外一個叫foo2的函數產生了更濃厚的興趣。

怎麼辦呢？若是把以上新增長的代碼複製到foo2裏，這就犯了大忌了~複製什麼的難道不是最討厭了麼！並且，若是B君繼續看了其餘的函數呢？

1.2. 以不變應萬變，是變也

還記得嗎，函數在Python中是一等公民，那麼咱們能夠考慮從新定義一個函數timeit，將foo的引用傳遞給他，而後在timeit中調用foo並進行計時，這樣，咱們就達到了不改動foo定義的目的，並且，不論B君看了多少個函數，咱們都不用去修改函數定義了！

1 2 3 4 5 6 7 8 9 10 11 12

import time   def foo():     print 'in foo()'   def timeit(func):     start= time.clock()     func()     end=time.clock()     print 'used:', end- start   timeit(foo)

看起來邏輯上並無問題，一切都很美好而且運做正常！……等等，咱們彷佛修改了調用部分的代碼。本來咱們是這樣調用的：foo()，修改之後變成了：timeit(foo)。這樣的話，若是foo在N處都被調用了，你就不得不去修改這N處的代碼。或者更極端的，考慮其中某處調用的代碼沒法修改這個狀況，好比：這個函數是你交給別人使用的。

1.3. 最大限度地少改動！

既然如此，咱們就來想一想辦法不修改調用的代碼；若是不修改調用代碼，也就意味着調用foo()須要產生調用timeit(foo)的效果。咱們能夠想到將timeit賦值給foo，可是timeit彷佛帶有一個參數……想辦法把參數統一吧！若是timeit(foo)不是直接產生調用效果，而是返回一個與foo參數列表一致的函數的話……就很好辦了，將timeit(foo)的返回值賦值給foo，而後，調用foo()的代碼徹底不用修改！

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#-*- coding: UTF-8 -*- import time   def foo():     print 'in foo()'   # 定義一個計時器，傳入一個，並返回另外一個附加了計時功能的方法 def timeit(func):           # 定義一個內嵌的包裝函數，給傳入的函數加上計時功能的包裝     def wrapper():         start= time.clock()         func()         end=time.clock()         print 'used:', end- start           # 將包裝後的函數返回     return wrapper   foo= timeit(foo) foo()

這樣，一個簡易的計時器就作好了！咱們只須要在定義foo之後調用foo以前，加上foo = timeit(foo)，就能夠達到計時的目的，這也就是裝飾器的概念，看起來像是foo被timeit裝飾了。在在這個例子中，函數進入和退出時須要計時，這被稱爲一個橫切面(Aspect)，這種編程方式被稱爲面向切面的編程(Aspect-Oriented Programming)。與傳統編程習慣的從上往下執行方式相比較而言，像是在函數執行的流程中橫向地插入了一段邏輯。在特定的業務領域裏，能減小大量重複代碼。面向切面編程還有至關多的術語，這裏就很少作介紹，感興趣的話能夠去找找相關的資料。

這個例子僅用於演示，並無考慮foo帶有參數和有返回值的狀況，完善它的重任就交給你了 ：）

2. Python的額外支持

2.1. 語法糖

上面這段代碼看起來彷佛已經不能再精簡了，Python因而提供了一個語法糖來下降字符輸入量。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

import time   def timeit(func):     def wrapper():         start= time.clock()         func()         end=time.clock()         print 'used:', end- start     return wrapper   @timeit def foo():     print 'in foo()'   foo()

重點關注第11行的@timeit，在定義上加上這一行與另外寫foo = timeit(foo)徹底等價，千萬不要覺得@有另外的魔力。除了字符輸入少了一些，還有一個額外的好處：這樣看上去更有裝飾器的感受。

2.2. 內置的裝飾器

內置的裝飾器有三個，分別是staticmethod、classmethod和property，做用分別是把類中定義的實例方法變成靜態方法、類方法和類屬性。因爲模塊裏能夠定義函數，因此靜態方法和類方法的用處並非太多，除非你想要徹底的面向對象編程。而屬性也不是不可或缺的，Java沒有屬性也同樣活得很滋潤。從我我的的Python經驗來看，我沒有使用過property，使用staticmethod和classmethod的頻率也很是低。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class Rabbit(object):           def __init__(self, name):         self._name= name           @staticmethod     def newRabbit(name):         return Rabbit(name)           @classmethod     def newRabbit2(cls):         return Rabbit('')           @property     def name(self):         return self._name

這裏定義的屬性是一個只讀屬性，若是須要可寫，則須要再定義一個setter：

1 2 3

@name.setter def name(self, name):     self._name= name

2.3. functools模塊

functools模塊提供了兩個裝飾器。這個模塊是Python 2.5後新增的，通常來講你們用的應該都高於這個版本。但我平時的工做環境是2.4 T-T

2.3.1. wraps(wrapped[, assigned][, updated]): 
這是一個頗有用的裝飾器。看過前一篇反射的朋友應該知道，函數是有幾個特殊屬性好比函數名，在被裝飾後，上例中的函數名foo會變成包裝函數的名字wrapper，若是你但願使用反射，可能會致使意外的結果。這個裝飾器能夠解決這個問題，它能將裝飾過的函數的特殊屬性保留。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

import time import functools   def timeit(func):     @functools.wraps(func)     def wrapper():         start= time.clock()         func()         end=time.clock()         print 'used:', end- start     return wrapper   @timeit def foo():     print 'in foo()'   foo() print foo.__name__

首先注意第5行，若是註釋這一行，foo.__name__將是'wrapper'。另外相信你也注意到了，這個裝飾器居然帶有一個參數。實際上，他還有另外兩個可選的參數，assigned中的屬性名將使用賦值的方式替換，而updated中的屬性名將使用update的方式合併，你能夠經過查看functools的源代碼得到它們的默認值。對於這個裝飾器，至關於wrapper = functools.wraps(func)(wrapper)。

2.3.2. total_ordering(cls): 
這個裝飾器在特定的場合有必定用處，可是它是在Python 2.7後新增的。它的做用是爲實現了至少__lt__、__le__、__gt__、__ge__其中一個的類加上其餘的比較方法，這是一個類裝飾器。若是以爲很差理解，不妨仔細看看這個裝飾器的源代碼：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

53  def total_ordering(cls): 54      """Class decorator that fills in missing ordering methods""" 55      convert= { 56          '__lt__': [('__gt__',lambda self, other: other <self), 57                     ('__le__',lambda self, other:not other <self), 58                     ('__ge__',lambda self, other:not self < other)], 59          '__le__': [('__ge__',lambda self, other: other <= self), 60                     ('__lt__',lambda self, other:not other <= self), 61                     ('__gt__',lambda self, other:not self <= other)], 62          '__gt__': [('__lt__',lambda self, other: other >self), 63                     ('__ge__',lambda self, other:not other >self), 64                     ('__le__',lambda self, other:not self > other)], 65          '__ge__': [('__le__',lambda self, other: other >= self), 66                     ('__gt__',lambda self, other:not other >= self), 67                     ('__lt__',lambda self, other:not self >= other)] 68      } 69      roots= set(dir(cls)) &set(convert) 70      if not roots: 71          raise ValueError('must define at least one ordering operation: < > <= >=') 72      root= max(roots)      # prefer __lt__ to __le__ to __gt__ to __ge__ 73      for opname, opfuncin convert[root]: 74          if opnamenot in roots: 75              opfunc.__name__= opname 76              opfunc.__doc__= getattr(int, opname).__doc__ 77              setattr(cls, opname, opfunc) 78      return cls

本文到這裏就所有結束了，有空的話我會整理一個用於檢查參數類型的裝飾器的源代碼放上來，算是一個應用吧 ：）