使用Python怎么實現(xiàn)一個類裝飾器？相信很多沒有經(jīng)驗的人對此束手無策，為此本文總結(jié)了問題出現(xiàn)的原因和解決方法，通過這篇文章希望你能解決這個問題。
編寫類裝飾器
類裝飾器類似于函數(shù)裝飾器的概念，但它應(yīng)用于類，它們可以用于管理類自身，或者用來攔截實例創(chuàng)建調(diào)用以管理實例。
單體類
由于類裝飾器可以攔截實例創(chuàng)建調(diào)用，所以它們可以用來管理一個類的所有實例，或者擴(kuò)展這些實例的接口。
下面的類裝飾器實現(xiàn)了傳統(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
為了使用它，裝飾用來強(qiáng)化單體模型的類：
@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)現(xiàn)在，當(dāng)Person或Spam類稍后用來創(chuàng)建一個實例的時候，裝飾器提供的包裝邏輯層把實例構(gòu)建調(diào)用指向了onCall，它反過來調(diào)用getInstance，以針對每個類管理并分享一個單個實例，而不管進(jìn)行了多少次構(gòu)建調(diào)用。
程序輸出如下：
Bob 400
Bob 400
42 42
在這里，我們使用全局的字典instances來保存實例，還有一個更好的解決方案就是使用Python3中的nonlocal關(guān)鍵字，它可以為每個類提供一個封閉的作用域，如下：
def singleton(aClass): instance = None def onCall(*args): nonlocal instance if instance == None: instance = aClass(*args) return instance return onCall
當(dāng)然，我們也可以用類來編寫這個裝飾器——如下代碼對每個類使用一個實例，而不是使用一個封閉作用域或全局表：
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
跟蹤對象接口
類裝飾器的另一個常用場景是每個產(chǎn)生實例的接口。類裝飾器基本上可以在實例上安裝一個包裝器邏輯層，來以某種方式管理其對接口的訪問。
前面，我們知道可以用__getattr__運(yùn)算符重載方法作為包裝嵌入到實例的整個對象接口的方法，以便實現(xiàn)委托編碼模式。__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類攔截了對任何包裝對象的屬性的訪問，打印出一條跟蹤信息，并且使用內(nèi)置函數(shù)getattr來終止對包裝對象的請求。
類裝飾器為編寫這種__getattr__技術(shù)來包裝一個完整接口提供了一個替代的、方便的方法。如下：
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)建調(diào)用，這里的類裝飾器允許我們跟蹤整個對象接口，例如，對其任何屬性的訪問。
Spam和Person類的實例上的屬性獲取都會調(diào)用Wrapper類中的__getattr__邏輯，由于food和bob確實都是Wrapper的實例，得益于裝飾器的實例創(chuàng)建調(diào)用重定向，輸出如下：
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]
示例：實現(xiàn)私有屬性
如下的類裝飾器實現(xiàn)了一個用于類實例屬性的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())這個示例運(yùn)用了裝飾器參數(shù)等語法，稍微有些復(fù)雜，運(yùn)行結(jié)果如下：
python的五大特點是什么[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]
python的五大特點：1.簡單易學(xué)，開發(fā)程序時，專注的是解決問題,而不是搞明白語言本身。2.面向?qū)ο?，與其他主要的語言如C++和Java相比, Python以一種非常強(qiáng)大又簡單的方式實現(xiàn)面向?qū)ο缶幊獭?.可移植性，Python程序無需修改就可以在各種平臺上運(yùn)行。4.解釋性，Python語言寫的程序不需要編譯成二進(jìn)制代碼,可以直接從源代碼運(yùn)行程序。5.開源，Python是 FLOSS(自由/開放源碼軟件)之一。
看完上述內(nèi)容，你們掌握使用Python怎么實現(xiàn)一個類裝飾器的方法了嗎？如果還想學(xué)到更多技能或想了解更多相關(guān)內(nèi)容，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，感謝各位的閱讀！
