Python黑魔法Descriptor描述符的實(shí)例解析
在Python中，訪問(wèn)一個(gè)屬性的優(yōu)先級(jí)順序按照如下順序:
1:類屬性
2:數(shù)據(jù)描述符
3:實(shí)例屬性
4:非數(shù)據(jù)描述符
5:__getattr__()方法 這個(gè)方法的完整定義如下所示:
def __getattr(self,attr) :#attr是self的一個(gè)屬性名 pass;
先來(lái)闡述下什么叫數(shù)據(jù)描述符。
數(shù)據(jù)描述符是指實(shí)現(xiàn)了__get__,__set__,__del__方法的類屬性(由于Python中，一切皆是對(duì)象，所以你不妨把所有的屬性也看成是對(duì)象)
PS:個(gè)人覺得這里最好把數(shù)據(jù)描述符等效于定義了__get__,__set__,__del__三個(gè)方法的接口。
__get__,__set__,__del__
闡述下這三個(gè)方法:
__get__的標(biāo)準(zhǔn)定義是__get__(self,obj,type=None)，它非常接近于JavaBean的get
第一個(gè)函數(shù)是調(diào)用它的實(shí)例，obj是指去訪問(wèn)屬性所在的方法，最后一個(gè)type是一個(gè)可選參數(shù)，通常為None(這個(gè)有待于進(jìn)一步的研究)
例如給定類X和實(shí)例x，調(diào)用x.foo，等效于調(diào)用:
type(x).__dict__['foo'].__get__(x,type(x))
調(diào)用X.foo，等效于調(diào)用:
type(x).__dict__['foo'].__get__(None,type(x))
第二個(gè)函數(shù)__set__的標(biāo)準(zhǔn)定義是__set__(self,obj,val)，它非常接近于JavaBean的set方法，其中最后一個(gè)參數(shù)是要賦予的值
第三個(gè)函數(shù)__del__的標(biāo)準(zhǔn)定義是__del__(self,obj)，它非常接近Java中Object的Finailize()方法，指Python在回收這個(gè)垃圾對(duì)象時(shí)所調(diào)用到的析構(gòu)函數(shù)，只是這個(gè)函數(shù)永遠(yuǎn)不會(huì)拋出異常。因?yàn)檫@個(gè)對(duì)象已經(jīng)沒有引用指向它，拋出異常沒有任何意義。
優(yōu)先級(jí)
接下來(lái)，我們來(lái)一一比較這些優(yōu)先級(jí).
首先來(lái)看類屬性
class A(object): foo=1.3; print str(A.__dict__);
輸出:
{'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__',
'foo': 1.3, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
從上圖可以看出foo屬性在類的__dict__屬性里，所以這里用A.foo可以直接找到。這里我們先跨過(guò)數(shù)據(jù)描述符，直接來(lái)看實(shí)例屬性.
class A(object): foo=1.3; a=A(); print a.foo; a.foo=15; print a.foo;
這里a.foo先輸出1.3后輸出15，不是說(shuō)類屬性的優(yōu)先級(jí)比實(shí)例屬性的優(yōu)先級(jí)高嗎？按理a.foo應(yīng)該不變才對(duì)?其實(shí)，這里只是一個(gè)假象，真正的原因在于這里將a.foo這個(gè)引用對(duì)象，不妨將其理解為可以指向任意數(shù)據(jù)類型的指針，指向了15這個(gè)int對(duì)象。
不信，可以繼續(xù)看:
class A(object): foo=1.3; a=A(); print a.foo; a.foo=15; print a.foo; del a.foo; print a.foo;
這次在輸出1.3，15后最后一次又一次的輸出了1.3，原因在于a.foo最后一次又按照優(yōu)先級(jí)順序直接找到了類屬性A.foo
描述器與對(duì)象屬性
OOP的理論中，類的成員變量包括屬性和方法。那么在Python里什么是屬性？修改上面的PythonSite類如下：
class PythonSite(object): webframework = WebFramework() version = 0.01 def __init__(self, site): self.site = site
這里增加了一個(gè)version的類屬性，以及一個(gè)實(shí)例屬性site。分別查看一下類和實(shí)例對(duì)象的屬性：
In [1]: pysite = PythonSite('ghost')
In [2]: vars(PythonSite).items()
Out[2]:
[('__module__', '__main__'),
('version', 0.01),
('__dict__', <attribute '__dict__' of 'PythonSite' objects>),
('webframework', <__main__.WebFramework at 0x10d55be90>),
('__weakref__', <attribute '__weakref__' of 'PythonSite' objects>),
('__doc__', None),
('__init__', <function __main__.__init__>)]
In [3]: vars(pysite)
Out[3]: {'site': 'ghost'}
In [4]: PythonSite.__dict__
Out[4]:
<dictproxy {'__dict__': <attribute '__dict__' of 'PythonSite' objects>,
'__doc__': None,
'__init__': <function __main__.__init__>,
'__module__': '__main__',
'__weakref__': <attribute '__weakref__' of 'PythonSite' objects>,
'version': 0.01,
'webframework': <__main__.WebFramework at 0x10d55be90>}>
vars方法用于查看對(duì)象的屬性，等價(jià)于對(duì)象的__dict__內(nèi)容。從上面的顯示結(jié)果，可以看到類PythonSite和實(shí)例pysite的屬性差別在于前者有 webframework，version兩個(gè)屬性，以及 __init__方法，后者僅有一個(gè)site屬性。
類與實(shí)例的屬性
類屬性可以使用對(duì)象和類訪問(wèn)，多個(gè)實(shí)例對(duì)象共享一個(gè)類變量。但是只有類才能修改。
In [6]: pysite1 = PythonSite('ghost')
In [7]: pysite2 = PythonSite('admin')
In [8]: PythonSite.version
Out[8]: 0.01
In [9]: pysite1.version
Out[9]: 0.01
In [10]: pysite2.version
Out[10]: 0.01
In [11]: pysite1.version is pysite2.version
Out[11]: True
In [12]: pysite1.version = 'pysite1'
In [13]: vars(pysite1)
Out[13]: {'site': 'ghost', 'version': 'pysite1'}
In [14]: vars(pysite2)
Out[14]: {'site': 'admin'}
In [15]: PythonSite.version = 0.02
In [16]: pysite1.version
Out[16]: 'pysite1'
In [17]: pysite2.version
Out[17]: 0.02
正如上面的代碼顯示，兩個(gè)實(shí)例對(duì)象都可以訪問(wèn)version類屬性，并且是同一個(gè)類屬性。當(dāng)pysite1修改了version，實(shí)際上是給自己添加了一個(gè)version屬性。類屬性并沒有被改變。當(dāng)PythonSite改變了version屬性的時(shí)候，pysite2的該屬性也對(duì)應(yīng)被改變。
屬性訪問(wèn)的原理與描述器
知道了屬性訪問(wèn)的結(jié)果。這個(gè)結(jié)果都是基于Python的描述器實(shí)現(xiàn)的。通常，類或者實(shí)例通過(guò).操作符訪問(wèn)屬性。例如pysite1.site和pysite1.version的訪問(wèn)。先訪問(wèn)對(duì)象的__dict__，如果沒有再訪問(wèn)類（或父類，元類除外）的__dict__。如果最后這個(gè)__dict__的對(duì)象是一個(gè)描述器，則會(huì)調(diào)用描述器的__get__方法。
In [21]: pysite1.site Out[21]: 'ghost' In [22]: pysite1.__dict__['site'] Out[22]: 'ghost' In [23]: pysite2.version Out[23]: 0.02 In [24]: pysite2.__dict__['version'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-24-73ef6aeba259> in <module>() ----> 1 pysite2.__dict__['version'] KeyError: 'version' In [25]: type(pysite2).__dict__['version'] Out[25]: 0.02 In [32]: type(pysite1).__dict__['webframework'] Out[32]: <__main__.WebFramework at 0x103426e90> In [38]: type(pysite1).__dict__['webframework'].__get__(None, PythonSite) Out[38]: 'Flask'
實(shí)例方法，類方法，靜態(tài)方法與描述器
調(diào)用描述器的時(shí)候，實(shí)際上會(huì)調(diào)用object.__getattribute__()。這取決于調(diào)用描述其器的是對(duì)象還是類，如果是對(duì)象obj.x，則會(huì)調(diào)用type(obj).__dict__['x'].__get__(obj, type(obj))。如果是類，class.x， 則會(huì)調(diào)用type(class).__dict__['x'].__get__(None, type(class)。
這樣說(shuō)還是比較抽象，下面來(lái)分析Python的方法，靜態(tài)方法和類方法。把PythonSite重構(gòu)一下：
class PythonSite(object): webframework = WebFramework() version = 0.01 def __init__(self, site): self.site = site def get_site(self): return self.site @classmethod def get_version(cls): return cls.version @staticmethod def find_version(): return PythonSite.version
類方法，@classmethod裝飾器
先看類方法，類方法使用@classmethod裝飾器定義。經(jīng)過(guò)該裝飾器的方法是一個(gè)描述器。類和實(shí)例都可以調(diào)用類方法：
In [1]: ps = PythonSite('ghost')
In [2]: ps.get_version
Out[2]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [3]: ps.get_version()
Out[3]: 0.01
In [4]: PythonSite.get_version
Out[4]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [5]: PythonSite.get_version()
Out[5]: 0.01
get_version 是一個(gè)bound方法。下面再看下ps.get_version這個(gè)調(diào)用，會(huì)先查找它·的__dict__是否有g(shù)et_version這個(gè)屬性，如果沒有，則查找其類。
In [6]: vars(ps)
Out[6]: {'site': 'ghost'}
In [7]: type(ps).__dict__['get_version']
Out[7]: <classmethod at 0x108952e18>
In [8]: type(ps).__dict__['get_version'].__get__(ps, type(ps))
Out[8]: <bound method type.get_version of <class '__main__.PythonSite'>>
In [9]: type(ps).__dict__['get_version'].__get__(ps, type(ps)) == ps.get_version
Out[9]: True
并且vars(ps)中，__dict__并沒有g(shù)et_version這個(gè)屬性，依據(jù)描述器協(xié)議，將會(huì)調(diào)用type(ps).__dict__['get_version']描述器的__get__方法，因?yàn)閜s是實(shí)例，因此object.__getattribute__()會(huì)這樣調(diào)用__get__(obj, type(obj))。
現(xiàn)在再看類方法的調(diào)用:
In [10]: PythonSite.__dict__['get_version'] Out[10]: <classmethod at 0x108952e18> In [11]: PythonSite.__dict__['get_version'].__get__(None, PythonSite) Out[11]: <bound method type.get_version of <class '__main__.PythonSite'>> In [12]: PythonSite.__dict__['get_version'].__get__(None, PythonSite) == PythonSite.get_version Out[12]: True
因?yàn)檫@次調(diào)用get_version的是一個(gè)類對(duì)象，而不是實(shí)例對(duì)象，因此object.__getattribute__()會(huì)這樣調(diào)用__get__(None, Class)。
靜態(tài)方法，@staticmethod
實(shí)例和類也可以調(diào)用靜態(tài)方法：
In [13]: ps.find_version
Out[13]: <function __main__.find_version>
In [14]: ps.find_version()
Out[14]: 0.01
In [15]: vars(ps)
Out[15]: {'site': 'ghost'}
In [16]: type(ps).__dict__['find_version']
Out[16]: <staticmethod at 0x108952d70>
In [17]: type(ps).__dict__['find_version'].__get__(ps, type(ps))
Out[17]: <function __main__.find_version>
In [18]: type(ps).__dict__['find_version'].__get__(ps, type(ps)) == ps.find_version
Out[18]: True
In [19]: PythonSite.find_version()
Out[19]: 0.01
In [20]: PythonSite.find_version
Out[20]: <function __main__.find_version>
In [21]: type(ps).__dict__['find_version'].__get__(None, type(ps))
Out[21]: <function __main__.find_version>
In [22]: type(ps).__dict__['find_version'].__get__(None, type(ps)) == PythonSite.find_version
Out[22]: True
和類方法差別不大，他們的主要差別是在類方法內(nèi)部的時(shí)候，類方法可以有cls的類引用，靜態(tài)訪問(wèn)則沒有，如果靜態(tài)方法想使用類變量，只能硬編碼類名。
實(shí)例方法
實(shí)例方法最為復(fù)雜，是專門屬于實(shí)例的，使用類調(diào)用的時(shí)候，會(huì)是一個(gè)unbound方法。
In [2]: ps.get_site Out[2]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>> In [3]: ps.get_site() Out[3]: 'ghost' In [4]: type(ps).__dict__['get_site'] Out[4]: <function __main__.get_site> In [5]: type(ps).__dict__['get_site'].__get__(ps, type(ps)) Out[5]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>> In [6]: type(ps).__dict__['get_site'].__get__(ps, type(ps)) == ps.get_site Out[6]: True
一切工作正常，實(shí)例方法也是類的一個(gè)屬性，但是對(duì)于類，描述器使其變成了unbound方法：
In [7]: PythonSite.get_site Out[7]: <unbound method PythonSite.get_site> In [8]: PythonSite.get_site() --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-99c7d7607137> in <module>() ----> 1 PythonSite.get_site() TypeError: unbound method get_site() must be called with PythonSite instance as first argument (got nothing instead) In [9]: PythonSite.get_site(ps) Out[9]: 'ghost' In [10]: PythonSite.__dict__['get_site'] Out[10]: <function __main__.get_site> In [11]: PythonSite.__dict__['get_site'].__get__(None, PythonSite) Out[11]: <unbound method PythonSite.get_site> In [12]: PythonSite.__dict__['get_site'].__get__(None, PythonSite) == PythonSite.get_site Out[12]: True In [14]: PythonSite.__dict__['get_site'].__get__(ps, PythonSite) Out[14]: <bound method PythonSite.get_site of <__main__.PythonSite object at 0x1054ae2d0>> In [15]: PythonSite.__dict__['get_site'].__get__(ps, PythonSite)() Out[15]: 'ghost'
由此可見，類不能直接調(diào)用實(shí)例方法，除非在描述器手動(dòng)綁定一個(gè)類實(shí)例。因?yàn)槭褂妙悓?duì)象調(diào)用描述器的時(shí)候，__get__的第一個(gè)參數(shù)是None，想要成功調(diào)用，需要把這個(gè)參數(shù)替換為實(shí)例ps，這個(gè)過(guò)程就是對(duì)方法的bound過(guò)程。
實(shí)例
按照之前的定義，一個(gè)實(shí)現(xiàn)了__get__,__set__,__del__的類都統(tǒng)稱為數(shù)據(jù)描述符。我們來(lái)看下一個(gè)簡(jiǎn)單的例子.
class simpleDescriptor(object): def __get__(self,obj,type=None) : pass; def __set__(self,obj,val): pass; def __del__(self,obj): pass class A(object): foo=simpleDescriptor(); print str(A.__dict__); print A.foo; a=A(); print a.foo; a.foo=13; print a.foo;
這里get,set,del方法體內(nèi)容都略過(guò)，雖然簡(jiǎn)單，但也不失為一個(gè)數(shù)據(jù)描述符。讓我們來(lái)看下它的輸出:
{'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__',
'foo': <__main__.simpleDescriptor object at 0x00C46930>,
'__weakref__': <attribute '__weakref__' of 'A' objects>,
'__doc__': None}
None
None
None
從上圖可以看出，盡管我們對(duì)a.foo賦值了，但其依然為None，原因就在于__get__方法什么都不返回。
為了更進(jìn)一步的加深對(duì)數(shù)據(jù)描述符的理解，我們簡(jiǎn)單的作下改造.
class simpleDescriptor(object): def __init__(self): self.result=None; def __get__(self,obj,type=None) : return self.result-10; def __set__(self,obj,val): self.result=val+3; print self.result; def __del__(self,obj): pass class A(object): foo=simpleDescriptor(); a=A(); a.foo=13; print a.foo;
打印的輸出結(jié)果為:
16 6
第一個(gè)16為我們?cè)趯?duì)a.foo賦值的時(shí)候，人為的將13加上3后作為foo的值，第二個(gè)6是我們?cè)诜祷豠.foo之前人為的將它減去了10。
所以我們可以猜測(cè)，常規(guī)的Python類在定義get,set方法的時(shí)候，如果無(wú)特殊需求，直接給對(duì)應(yīng)的屬性賦值或直接返回該屬性值。如果自己定義類，并且繼承object類的話，這幾個(gè)方法都不用定義。
下面我們來(lái)看下實(shí)例屬性和非數(shù)據(jù)描述符。
class B(object): foo=1.3; b=B(); print b.__dict__ #print b.bar; b.bar=13; print b.__dict__ print b.bar;
輸出結(jié)果為:
{}
{'bar': 13}
13
可見這里在實(shí)例b.__dict__里找到了bar屬性，所以這次可以獲取13了
那么什么是非數(shù)據(jù)描述符呢？簡(jiǎn)單的說(shuō)，就是沒有實(shí)現(xiàn)get,set,del三個(gè)方法的所有類
讓我們?nèi)我饪匆粋€(gè)函數(shù)的描述:
def hello(): pass print dir(hello)
輸出:
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
從上面可以看出所有的函數(shù)都有g(shù)et方法，但都沒有set和del方法，所以所有的類成員函數(shù)都是非數(shù)據(jù)描述符。
看一個(gè)簡(jiǎn)單的例子:
class simpleDescriptor(object): def __get__(self,obj,type=None) : return 'get',self,obj,type; class D(object): foo=simpleDescriptor(); d=D(); print d.foo; d.foo=15; print d.foo;
輸出:
('get', <__main__.simpleDescriptor object at 0x00C46870>,
<__main__.D object at 0x00C46890>, <class '__main__.D'>)
15
可以看出實(shí)例屬性掩蓋了非數(shù)據(jù)描述符。
最后看下__getatrr__方法。它的標(biāo)準(zhǔn)定義是:__getattr__(self,attr)，其中attr是屬性名
讓我們來(lái)看一個(gè)簡(jiǎn)單的例子:
class D(object): def __getattr__(self,attr): return attr; #return self.attr; d=D(); print d.foo,type(d.foo); d.foo=15; print d.foo;
輸出:
foo <type 'str'> 15
可以看的出來(lái)Python在實(shí)在找不到方法的時(shí)候，就會(huì)求助于__getattr__方法。
注意這里要避免無(wú)意識(shí)的遞歸，稍微改動(dòng)下:
class D(object): def __getattr__(self,attr): #return attr; return self.attr; d=D(); print d.foo,type(d.foo); d.foo=15; print d.foo;
這次會(huì)直接拋出堆棧溢出的異常，就像下面這樣:
RuntimeError: maximum recursion depth exceeded
- Python黑魔法遠(yuǎn)程控制開機(jī)的實(shí)例
- Python黑魔法@property裝飾器的使用技巧解析
- python黑魔法之參數(shù)傳遞
- python黑魔法之編碼轉(zhuǎn)換
- 詳解python metaclass（元類）
- python中metaclass原理與用法詳解
- Python探索之Metaclass初步了解
- 舉例講解Python中metaclass元類的創(chuàng)建與使用
- 詳解python單例模式與metaclass
- Python使用metaclass實(shí)現(xiàn)Singleton模式的方法
- Python中的Classes和Metaclasses詳解
- 深入理解Python中的元類(metaclass)
- Python黑魔法之metaclass詳情
相關(guān)文章
Python的schedule模塊是一個(gè)輕量級(jí)的Python庫(kù),用于在指定時(shí)間執(zhí)行某些操作,本文就來(lái)介紹一下Python中schedule擴(kuò)展的具體使用,感興趣的可以了解一下2024-12-12
這篇文章主要介紹了python檢測(cè)代理ip是否有效問(wèn)題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2023-08-08
這篇文章主要介紹了python如何通過(guò)跳板機(jī)連接MySQL問(wèn)題，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2022-12-12
python回溯法實(shí)現(xiàn)數(shù)組全排列輸出實(shí)例分析
這篇文章主要介紹了python回溯法實(shí)現(xiàn)數(shù)組全排列輸出,以實(shí)例形式較為詳細(xì)的分析了全排列的定義及回溯法的實(shí)現(xiàn)技巧,需要的朋友可以參考下2015-03-03
Python?打印不帶括號(hào)的元組的實(shí)現(xiàn)
本文主要介紹了Python?打印不帶括號(hào)的元組，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2023-04-04
Python基于機(jī)器學(xué)習(xí)方法實(shí)現(xiàn)的電影推薦系統(tǒng)實(shí)例詳解
這篇文章主要介紹了Python基于機(jī)器學(xué)習(xí)方法實(shí)現(xiàn)的電影推薦系統(tǒng),本文給大家介紹的非常詳細(xì)，具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2019-06-06
tensorflow模型文件(ckpt)轉(zhuǎn)pb文件的方法（不知道輸出節(jié)點(diǎn)名）
這篇文章主要介紹了tensorflow模型文件(ckpt)轉(zhuǎn)pb文件（不知道輸出節(jié)點(diǎn)名），本文通過(guò)實(shí)例代碼給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2020-04-04
Python拆分Excel工作簿或工作表為多個(gè)文件的高效方法
在日常工作中,我們經(jīng)常需要處理包含大量數(shù)據(jù)的Excel文件,為了提高效率和準(zhǔn)確性,我們可以將一個(gè)Excel文件或其中某一個(gè)工作表按需求拆分為多個(gè)文件,本文將提供以下兩個(gè)示例介紹如何通過(guò)Python高效地拆分Excel工作簿或工作表,需要的朋友可以參考下2024-12-12
Python和Java進(jìn)行DES加密和解密的實(shí)例
下面小編就為大家分享一篇Python和Java進(jìn)行DES加密和解密的實(shí)例，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2018-01-01
Python的化簡(jiǎn)函數(shù)reduce()詳解
這篇文章主要介紹了Python的化簡(jiǎn)函數(shù)reduce()詳解,reduce()函數(shù)即為化簡(jiǎn)函數(shù),它的執(zhí)行過(guò)程為：每一次迭代,都將上一次的迭代結(jié)果與下一個(gè)元素一同傳入二元func函數(shù)中去執(zhí)行,需要的朋友可以參考下2023-12-12