@本文來源於公衆號:csdn2299,喜歡可以關注公衆號 程序員學府
與迭代器和裝飾器等一樣,描述符也是Python編程中的一項高級技巧,這裏我們就來講解Python黑魔法Descriptor描述符的實例解析:
在Python中,訪問一個屬性的優先級順序按照如下順序:
1:類屬性
2:數據描述符
3:實例屬性
4:非數據描述符
5:getattr()方法 這個方法的完整定義如下所示:
def __getattr(self,attr) :#attr是self的一個屬性名
pass;
先來闡述下什麼叫數據描述符。
數據描述符是指實現了__get__,set,del__方法的類屬性(由於Python中,一切皆是對象,所以你不妨把所有的屬性也看成是對象)
PS:個人覺得這裏最好把數據描述符等效於定義了__get,set,__del__三個方法的接口。
get,set,del
闡述下這三個方法:
get__的標準定義是__get(self,obj,type=None),它非常接近於JavaBean的get
第一個函數是調用它的實例,obj是指去訪問屬性所在的方法,最後一個type是一個可選參數,通常爲None(這個有待於進一步的研究)
例如給定類X和實例x,調用x.foo,等效於調用:
type(x).__dict__['foo'].__get__(x,type(x))
調用X.foo,等效於調用:
type(x).__dict__['foo'].__get__(None,type(x))
第二個函數__set__的標準定義是__set__(self,obj,val),它非常接近於JavaBean的set方法,其中最後一個參數是要賦予的值
第三個函數__del__的標準定義是__del__(self,obj),它非常接近Java中Object的Finailize()方法,指Python在回收這個垃圾對象時所調用到的析構函數,只是這個函數永遠不會拋出異常。因爲這個對象已經沒有引用指向它,拋出異常沒有任何意義。
優先級
接下來,我們來一一比較這些優先級.
首先來看類屬性
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可以直接找到。這裏我們先跨過數據描述符,直接來看實例屬性.
class A(object):
foo=1.3;
a=A();
print a.foo;
a.foo=15;
print a.foo;
這裏a.foo先輸出1.3後輸出15,不是說類屬性的優先級比實例屬性的優先級高嗎?按理a.foo應該不變纔對?其實,這裏只是一個假象,真正的原因在於這裏將a.foo這個引用對象,不妨將其理解爲可以指向任意數據類型的指針,指向了15這個int對象。
不信,可以繼續看:
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最後一次又按照優先級順序直接找到了類屬性A.foo
描述器與對象屬性
OOP的理論中,類的成員變量包括屬性和方法。那麼在Python裏什麼是屬性?修改上面的PythonSite類如下:
class PythonSite(object):
webframework = WebFramework()
version = 0.01
def __init__(self, site):
self.site = site
這裏增加了一個version的類屬性,以及一個實例屬性site。分別查看一下類和實例對象的屬性:
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方法用於查看對象的屬性,等價於對象的__dict__內容。從上面的顯示結果,可以看到類PythonSite和實例pysite的屬性差別在於前者有 webframework,version兩個屬性,以及 __init__方法,後者僅有一個site屬性。
類與實例的屬性
類屬性可以使用對象和類訪問,多個實例對象共享一個類變量。但是隻有類才能修改。
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
正如上面的代碼顯示,兩個實例對象都可以訪問version類屬性,並且是同一個類屬性。當pysite1修改了version,實際上是給自己添加了一個version屬性。類屬性並沒有被改變。當PythonSite改變了version屬性的時候,pysite2的該屬性也對應被改變。
屬性訪問的原理與描述器
知道了屬性訪問的結果。這個結果都是基於Python的描述器實現的。通常,類或者實例通過.操作符訪問屬性。例如pysite1.site和pysite1.version的訪問。先訪問對象的__dict__,如果沒有再訪問類(或父類,元類除外)的__dict__。如果最後這個__dict__的對象是一個描述器,則會調用描述器的__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'
實例方法,類方法,靜態方法與描述器
調用描述器的時候,實際上會調用object.getattribute()。這取決於調用描述其器的是對象還是類,如果是對象obj.x,則會調用type(obj).dict[‘x’].get(obj, type(obj))。如果是類,class.x, 則會調用type(class).dict[‘x’].get(None, type(class)。
這樣說還是比較抽象,下面來分析Python的方法,靜態方法和類方法。把PythonSite重構一下:
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裝飾器定義。經過該裝飾器的方法是一個描述器。類和實例都可以調用類方法:
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 是一個bound方法。下面再看下ps.get_version這個調用,會先查找它·的__dict__是否有get_version這個屬性,如果沒有,則查找其類。
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__並沒有get_version這個屬性,依據描述器協議,將會調用type(ps).__dict__['get_version']描述器的__get__方法,因爲ps是實例,因此object.__getattribute__()會這樣調用__get__(obj, type(obj))。
現在再看類方法的調用:
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
因爲這次調用get_version的是一個類對象,而不是實例對象,因此object.__getattribute__()會這樣調用__get__(None, Class)。
靜態方法,@staticmethod
實例和類也可以調用靜態方法:
In [13]: ps.find_version
Out[13]:
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]:
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]:
In [21]: type(ps).dict[‘find_version’].get(None, type(ps))
Out[21]:
In [22]: type(ps).dict[‘find_version’].get(None, type(ps)) == PythonSite.find_version
Out[22]: True
和類方法差別不大,他們的主要差別是在類方法內部的時候,類方法可以有cls的類引用,靜態訪問則沒有,如果靜態方法想使用類變量,只能硬編碼類名。
實例方法
實例方法最爲複雜,是專門屬於實例的,使用類調用的時候,會是一個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]:
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
一切工作正常,實例方法也是類的一個屬性,但是對於類,描述器使其變成了unbound方法:
In [7]: PythonSite.get_site
Out[7]:
In [8]: PythonSite.get_site()
TypeError Traceback (most recent call last)
in ()
----> 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]:
In [11]: PythonSite.dict[‘get_site’].get(None, PythonSite)
Out[11]:
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’
由此可見,類不能直接調用實例方法,除非在描述器手動綁定一個類實例。因爲使用類對象調用描述器的時候,__get__的第一個參數是None,想要成功調用,需要把這個參數替換爲實例ps,這個過程就是對方法的bound過程。
實例
按照之前的定義,一個實現了__get__,__set__,__del__的類都統稱爲數據描述符。我們來看下一個簡單的例子.
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方法體內容都略過,雖然簡單,但也不失爲一個數據描述符。讓我們來看下它的輸出:
{‘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
從上圖可以看出,儘管我們對a.foo賦值了,但其依然爲None,原因就在於__get__方法什麼都不返回。
爲了更進一步的加深對數據描述符的理解,我們簡單的作下改造.
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;
打印的輸出結果爲:
16
6
第一個16爲我們在對a.foo賦值的時候,人爲的將13加上3後作爲foo的值,第二個6是我們在返回a.foo之前人爲的將它減去了10。
所以我們可以猜測,常規的Python類在定義get,set方法的時候,如果無特殊需求,直接給對應的屬性賦值或直接返回該屬性值。如果自己定義類,並且繼承object類的話,這幾個方法都不用定義。
下面我們來看下實例屬性和非數據描述符。
class B(object):
foo=1.3;
b=B();
print b.dict
#print b.bar;
b.bar=13;
print b.dict
print b.bar;
輸出結果爲:
{}
{‘bar’: 13}
13
可見這裏在實例b.__dict__裏找到了bar屬性,所以這次可以獲取13了
那麼什麼是非數據描述符呢?簡單的說,就是沒有實現get,set,del三個方法的所有類
讓我們任意看一個函數的描述:
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’]
從上面可以看出所有的函數都有get方法,但都沒有set和del方法,所以所有的類成員函數都是非數據描述符。
看一個簡單的例子:
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
可以看出實例屬性掩蓋了非數據描述符。
最後看下__getatrr__方法。它的標準定義是:__getattr__(self,attr),其中attr是屬性名
讓我們來看一個簡單的例子:
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
可以看的出來Python在實在找不到方法的時候,就會求助於__getattr__方法。
注意這裏要避免無意識的遞歸,稍微改動下:
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;
這次會直接拋出堆棧溢出的異常,就像下面這樣:
RuntimeError: maximum recursion depth exceeded
非常感謝你的閱讀
大學的時候選擇了自學python,工作了發現吃了計算機基礎不好的虧,學歷不行這是沒辦法的事,只能後天彌補,於是在編碼之外開啓了自己的逆襲之路,不斷的學習python核心知識,深入的研習計算機基礎知識,整理好了,我放在我們的Python學習扣qun:774711191,如果你也不甘平庸,那就與我一起在編碼之外,不斷成長吧!
其實這裏不僅有技術,更有那些技術之外的東西,比如,如何做一個精緻的程序員,而不是“屌絲”,程序員本身就是高貴的一種存在啊,難道不是嗎?[\[點擊加入\]](https://jq.qq.com/?_wv=1027&k=5ipV5It)
想做你自己想成爲高尚人,加油!