激情久久久_欧美视频区_成人av免费_不卡视频一二三区_欧美精品在欧美一区二区少妇_欧美一区二区三区的

腳本之家，腳本語言編程技術及教程分享平臺！
分類導航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服務器之家 - 腳本之家 - Python - Python黑魔法Descriptor描述符的實例解析

Python黑魔法Descriptor描述符的實例解析

2020-08-25 09:30人世間 Python

與迭代器和裝飾器等一樣,描述符也是Python編程中的一項高級技巧,這里我們就來講解Python黑魔法Descriptor描述符的實例解析:

在Python中，訪問一個屬性的優先級順序按照如下順序:
1:類屬性
2:數據描述符
3:實例屬性
4:非數據描述符
5:__getattr__()方法  這個方法的完整定義如下所示:

?
1
2
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，等效于調用:

?
1
type(x).__dict__['foo'].__get__(x,type(x))

調用X.foo，等效于調用:

?
1
type(x).__dict__['foo'].__get__(None,type(x))

 
第二個函數__set__的標準定義是__set__(self,obj,val)，它非常接近于JavaBean的set方法，其中最后一個參數是要賦予的值
第三個函數__del__的標準定義是__del__(self,obj)，它非常接近Java中Object的Finailize()方法，指Python在回收這個垃圾對象時所調用到的析構函數，只是這個函數永遠不會拋出異常。因為這個對象已經沒有引用指向它，拋出異常沒有任何意義。
 
優先級
接下來，我們來一一比較這些優先級.
首先來看類屬性

?
1
2
3
4
class A(object):
 foo=1.3;
  
print str(A.__dict__);

輸出: 

?
1
2
3
{'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__',
 
'foo': 1.3, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

從上圖可以看出foo屬性在類的__dict__屬性里，所以這里用A.foo可以直接找到。這里我們先跨過數據描述符，直接來看實例屬性.

?
1
2
3
4
5
6
7
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對象。
不信，可以繼續看:

?
1
2
3
4
5
6
7
8
9
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類如下：

?
1
2
3
4
5
6
7
8
class PythonSite(object):
 
 webframework = WebFramework()
 
 version = 0.01
 
 def __init__(self, site):
 self.site = site

這里增加了一個version的類屬性，以及一個實例屬性site。分別查看一下類和實例對象的屬性：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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屬性。

類與實例的屬性
類屬性可以使用對象和類訪問，多個實例對象共享一個類變量。但是只有類才能修改。

?
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
27
28
29
30
31
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__方法。

?
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
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重構一下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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裝飾器定義。經過該裝飾器的方法是一個描述器。類和實例都可以調用類方法：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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這個屬性，如果沒有，則查找其類。

?
1
2
3
4
5
6
7
8
9
10
11
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))。

現在再看類方法的調用:

?
1
2
3
4
5
6
7
8
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
實例和類也可以調用靜態方法：

?
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
27
28
29
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

和類方法差別不大，他們的主要差別是在類方法內部的時候，類方法可以有cls的類引用，靜態訪問則沒有，如果靜態方法想使用類變量，只能硬編碼類名。

實例方法
實例方法最為復雜，是專門屬于實例的，使用類調用的時候，會是一個unbound方法。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

一切工作正常，實例方法也是類的一個屬性，但是對于類，描述器使其變成了unbound方法：

?
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
27
28
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'

由此可見，類不能直接調用實例方法，除非在描述器手動綁定一個類實例。因為使用類對象調用描述器的時候，__get__的第一個參數是None，想要成功調用，需要把這個參數替換為實例ps，這個過程就是對方法的bound過程。


實例 
按照之前的定義，一個實現了__get__,__set__,__del__的類都統稱為數據描述符。我們來看下一個簡單的例子.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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方法體內容都略過，雖然簡單，但也不失為一個數據描述符。讓我們來看下它的輸出:

?
1
2
3
4
5
6
7
{'__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__方法什么都不返回。
為了更進一步的加深對數據描述符的理解，我們簡單的作下改造.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;

打印的輸出結果為:

?
1
2
16
 6

第一個16為我們在對a.foo賦值的時候，人為的將13加上3后作為foo的值，第二個6是我們在返回a.foo之前人為的將它減去了10。
所以我們可以猜測，常規的Python類在定義get,set方法的時候，如果無特殊需求，直接給對應的屬性賦值或直接返回該屬性值。如果自己定義類，并且繼承object類的話，這幾個方法都不用定義。
下面我們來看下實例屬性和非數據描述符。

?
1
2
3
4
5
6
7
8
class B(object):
 foo=1.3;
b=B();
print b.__dict__
#print b.bar;
b.bar=13;
print b.__dict__
print b.bar;

輸出結果為:

?
1
2
3
4
{}
{'bar': 13}
13

可見這里在實例b.__dict__里找到了bar屬性，所以這次可以獲取13了
那么什么是非數據描述符呢？簡單的說，就是沒有實現get,set,del三個方法的所有類
讓我們任意看一個函數的描述:

?
1
2
3
4
def hello():
 pass
 
print dir(hello)

 
輸出:  

?
1
2
3
4
5
6
7
8
9
10
['__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方法，所以所有的類成員函數都是非數據描述符。
看一個簡單的例子:

?
1
2
3
4
5
6
7
8
9
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;

輸出:

?
1
2
3
4
('get', <__main__.simpleDescriptor object at 0x00C46870>,
 
<__main__.D object at 0x00C46890>, <class '__main__.D'>)
15

 
可以看出實例屬性掩蓋了非數據描述符。
最后看下__getatrr__方法。它的標準定義是:__getattr__(self,attr)，其中attr是屬性名
讓我們來看一個簡單的例子:

?
1
2
3
4
5
6
7
8
9
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;

 輸出:

?
1
2
foo <type 'str'>
15

 可以看的出來Python在實在找不到方法的時候，就會求助于__getattr__方法。
 注意這里要避免無意識的遞歸，稍微改動下:

?
1
2
3
4
5
6
7
8
9
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;

 
這次會直接拋出堆棧溢出的異常，就像下面這樣:

?
1
RuntimeError: maximum recursion depth exceeded

延伸 · 閱讀

精彩推薦
主站蜘蛛池模板： 免费在线观看午夜视频 | 一区小视频 | 男女做性免费网站 | 久久精品视频免费 | 日本中文高清 | 久久精品一区视频 | 亚洲成人欧美 | 亚洲一区二区在线视频 | 97精品国产高清在线看入口 | 原来神马影院手机版免费 | 日韩黄在线观看 | 精品无吗乱吗av国产爱色 | 国产视频精品在线 | 日韩高清影视 | 黄色片视频观看 | 91成人久久 | 欧美黄色免费视频 | 中文字幕在线观看成人 | 日日摸夜夜添夜夜添牛牛 | 精品国产视频一区二区三区 | va免费视频 | 国产一区二区三区视频免费 | 全免费午夜一级毛片真人 | 91精品免费在线 | 成人免费网站在线观看 | 成人激情视频网站 | 久久人人人 | 欧美日韩电影在线 | 久久久久久久久久久亚洲 | 九九色网站 | 中文字幕网在线 | 龙的两根好大拔不出去h | 一区二区三区欧美日韩 | 爱射av| 久色成人网| 久久96国产精品久久秘臀 | 久久久久久麻豆 | 成片免费观看视频大全 | 91成人影院 | 成年免费大片黄在线观看岛国 | 亚洲第一成人久久网站 |