Python類裝飾器實現方法詳解

更新時間：2018年12月21日 12:05:26 作者：KLeonard

這篇文章主要介紹了Python類裝飾器實現方法,結合實例形式較為詳細的分析了Python類裝飾器的相關概念、原理、實現方法與使用技巧,需要的朋友可以參考下

本文實例講述了Python類裝飾器。分享給大家供大家參考，具體如下：

編寫類裝飾器

類裝飾器類似于函數裝飾器的概念，但它應用于類，它們可以用于管理類自身，或者用來攔截實例創(chuàng)建調用以管理實例。

單體類

由于類裝飾器可以攔截實例創(chuàng)建調用，所以它們可以用來管理一個類的所有實例，或者擴展這些實例的接口。

下面的類裝飾器實現了傳統(tǒng)的單體編碼模式，即最多只有一個類的一個實例存在。

instances = {} # 全局變量，管理實例
def getInstance(aClass, *args):
  if aClass not in instances:
    instances[aClass] = aClass(*args)
  return instances[aClass]   #每一個類只能存在一個實例
def singleton(aClass):
  def onCall(*args):
    return getInstance(aClass,*args)
  return onCall
為了使用它，裝飾用來強化單體模型的類：
@singleton    # Person = singleton(Person)
class Person:
  def __init__(self,name,hours,rate):
    self.name = name
    self.hours = hours
    self.rate = rate
  def pay(self):
    return self.hours * self.rate
@singleton    # Spam = singleton(Spam)
class Spam:
  def __init__(self,val):
    self.attr = val
bob = Person('Bob',40,10)
print(bob.name,bob.pay())
sue = Person('Sue',50,20)
print(sue.name,sue.pay())
X = Spam(42)
Y = Spam(99)
print(X.attr,Y.attr)

現在，當Person或Spam類稍后用來創(chuàng)建一個實例的時候，裝飾器提供的包裝邏輯層把實例構建調用指向了onCall，它反過來調用getInstance，以針對每個類管理并分享一個單個實例，而不管進行了多少次構建調用。

程序輸出如下：

Bob 400
Bob 400
42 42

在這里，我們使用全局的字典instances來保存實例，還有一個更好的解決方案就是使用Python3中的nonlocal關鍵字，它可以為每個類提供一個封閉的作用域，如下：

def singleton(aClass):
 instance = None
 def onCall(*args):
 nonlocal instance
 if instance == None:
  instance = aClass(*args)
 return instance
 return onCall

當然，我們也可以用類來編寫這個裝飾器——如下代碼對每個類使用一個實例，而不是使用一個封閉作用域或全局表：

class singleton:
 def __init__(self,aClass):
 self.aClass = aClass
 self.instance = None
 def __call__(self,*args):
 if self.instance == None:
  self.instance = self.aClass(*args)
 return self.instance

跟蹤對象接口

類裝飾器的另一個常用場景是每個產生實例的接口。類裝飾器基本上可以在實例上安裝一個包裝器邏輯層，來以某種方式管理其對接口的訪問。

前面，我們知道可以用__getattr__運算符重載方法作為包裝嵌入到實例的整個對象接口的方法，以便實現委托編碼模式。__getattr__用于攔截未定義的屬性名的訪問。如下例子所示：

class Wrapper:
 def __init__(self,obj):
 self.wrapped = obj
 def __getattr__(self,attrname):
 print('Trace:',attrname)
 return getattr(self.wrapped,attrname)
>>> x = Wrapper([1,2,3])
>>> x.append(4)
Trace: append
>>> x.wrapped
[1, 2, 3, 4]
>>>
>>> x = Wrapper({'a':1,'b':2})
>>> list(x.keys())
Trace: keys
['b', 'a']

在這段代碼中，Wrapper類攔截了對任何包裝對象的屬性的訪問，打印出一條跟蹤信息，并且使用內置函數getattr來終止對包裝對象的請求。

類裝飾器為編寫這種__getattr__技術來包裝一個完整接口提供了一個替代的、方便的方法。如下：

def Tracer(aClass):
  class Wrapper:
    def __init__(self,*args,**kargs):
      self.fetches = 0
      self.wrapped = aClass(*args,**kargs)
    def __getattr__(self,attrname):
      print('Trace:'+attrname)
      self.fetches += 1
      return getattr(self.wrapped,attrname)
  return Wrapper
@Tracer
class Spam:
  def display(self):
    print('Spam!'*8)
@Tracer
class Person:
  def __init__(self,name,hours,rate):
    self.name = name
    self.hours = hours
    self.rate = rate
  def pay(self):
    return self.hours * self.rate
food = Spam()
food.display()
print([food.fetches])
bob = Person('Bob',40,50)
print(bob.name)
print(bob.pay())
print('')
sue = Person('Sue',rate=100,hours = 60)
print(sue.name)
print(sue.pay())
print(bob.name)
print(bob.pay())
print([bob.fetches,sue.fetches])

通過攔截實例創(chuàng)建調用，這里的類裝飾器允許我們跟蹤整個對象接口，例如，對其任何屬性的訪問。

Spam和Person類的實例上的屬性獲取都會調用Wrapper類中的__getattr__邏輯，由于food和bob確實都是Wrapper的實例，得益于裝飾器的實例創(chuàng)建調用重定向，輸出如下：

Trace:display
Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!
[1]
Trace:name
Bob
Trace:pay
2000
Trace:name
Sue
Trace:pay
6000
Trace:name
Bob
Trace:pay
2000
[4, 2]

示例：實現私有屬性

如下的類裝飾器實現了一個用于類實例屬性的Private聲明，也就是說，屬性存儲在一個實例上，或者從其一個類繼承而來。不接受從裝飾的類的外部對這樣的屬性的獲取和修改訪問，但是，仍然允許類自身在其方法中自由地訪問那些名稱。類似于Java中的private屬性。

traceMe = False
def trace(*args):
  if traceMe:
    print('['+ ' '.join(map(str,args))+ ']')
def Private(*privates):
  def onDecorator(aClass):
    class onInstance:
      def __init__(self,*args,**kargs):
        self.wrapped = aClass(*args,**kargs)
      def __getattr__(self,attr):
        trace('get:',attr)
        if attr in privates:
          raise TypeError('private attribute fetch:'+attr)
        else:
          return getattr(self.wrapped,attr)
      def __setattr__(self,attr,value):
        trace('set:',attr,value)
        if attr == 'wrapped': # 這里捕捉對wrapped的賦值
          self.__dict__[attr] = value
        elif attr in privates:
          raise TypeError('private attribute change:'+attr)
        else: # 這里捕捉對wrapped.attr的賦值
          setattr(self.wrapped,attr,value)
    return onInstance
  return onDecorator
if __name__ == '__main__':
  traceMe = True
  @Private('data','size')
  class Doubler:
    def __init__(self,label,start):
      self.label = label
      self.data = start
    def size(self):
      return len(self.data)
    def double(self):
      for i in range(self.size()):
        self.data[i] = self.data[i] * 2
    def display(self):
      print('%s => %s'%(self.label,self.data))
  X = Doubler('X is',[1,2,3])
  Y = Doubler('Y is',[-10,-20,-30])
  print(X.label)
  X.display()
  X.double()
  X.display()
  print(Y.label)
  Y.display()
  Y.double()
  Y.label = 'Spam'
  Y.display()
  # 這些訪問都會引發(fā)異常
  """
  print(X.size())
  print(X.data)
  X.data = [1,1,1]
  X.size = lambda S:0
  print(Y.data)
  print(Y.size())

這個示例運用了裝飾器參數等語法，稍微有些復雜，運行結果如下：

[set: wrapped <__main__.Doubler object at 0x03421F10>]
[set: wrapped <__main__.Doubler object at 0x031B7470>]
[get: label]
X is
[get: display]
X is => [1, 2, 3]
[get: double]
[get: display]
X is => [2, 4, 6]
[get: label]
Y is
[get: display]
Y is => [-10, -20, -30]
[get: double]
[set: label Spam]
[get: display]
Spam => [-20, -40, -60]