Python裝飾器實例(2):面向切面編程

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, opfunc in  convert[root]: 74           if  opname not  in  roots: 75               opfunc.__name__ =  opname 76               opfunc.__doc__ =  getattr ( int , opname).__doc__ 77               setattr ( cls , opname, opfunc) 78       return  cls