類屬性python
屬性的訪問機制
一般情況下，屬性訪問的默認行為是從對象的字典中獲取，並當獲取不到時會沿著一定的查找鏈進行查找。例如a.x的查找鏈就是，從a.__dict__['x']，然後是type(a).__dict__['x']，再通過type(a)的基類開始查找。
若查找鏈都獲取不到屬性，則拋出AttributeError異常。
一、__getattr__方法
這個方法是當對象的屬性不存在是調用。如果通過正常的機制能找到對象屬性的話，不會調用__getattr__方法。
classA:
a=1
def__getattr__(self,item):
print('__getattr__call')
returnitem
t=A()
print(t.a)
print(t.b)
#output
1
__getattr__call
b
二、__getattribute__方法
這個方法會被無條件調用。不管屬性存不存在。如果類中還定義了__getattr__，則不會調用__getattr__()方法，除非在__getattribute__方法中顯示調用__getattr__()或者拋出了AttributeError。
classA:
a=1
def__getattribute__(self,item):
print('__getattribute__call')
raiseAttributeError
def__getattr__(self,item):
print('__getattr__call')
returnitem
t=A()
print(t.a)
print(t.b)
所以一般情況下，為了保留__getattr__的作用，__getattribute__()方法中一般返回父類的同名方法：
def__getattribute__(self,item):
returnobject.__getattribute__(self,item)
使用基類的方法來獲取屬性能避免在方法中出現無限遞歸的情況。
三、__get__方法
這個方法比較簡單說明，它與前面的關系不大。
如果一個類中定義了__get__(),__set__()或__delete__()中的任何方法。則這個類的對象稱為描述符。
classDescri(object):
def__get__(self,obj,type=None):
print("callget")
def__set__(self,obj,value):
print("callset")
classA(object):
x=Descri()
a=A()
a.__dict__['x']=1#不會調用__get__
a.x#調用__get__
如果查找的屬性是在描述符對象中，則這個描述符會覆蓋上文說的屬性訪問機制，體現在查找鏈的不同，而這個行文也會因為調用的不同而稍有不一樣：
- 如果調用是對象實例(題目中的調用方式)，a.x則轉換為調用：。type(a).__dict__['x'].__get__(a, type(a))
- 如果調用的是類屬性,A.x則轉換為：A.__dict__['x'].__get__(None, A)
其他情況見文末參考資料的文檔
- 這個調用也屬於無條件調用，這點與__getattribute__一致。區別在於__getitem__讓類實例允許[]運算，可以這樣理解：
- __getattribute__適用於所有.運算符；
- __getitem__適用於所有[]運算符。
- classA(object):
- a=1
- def__getitem__(self,item):
- print('__getitem__call')
- returnitem
- t=A()
- print(t['a'])
- print(t['b'])
- def__getitem(self,item):
- returnobject.__getattribute__(self,item)
- classC(object):
- a='abc'
- def__getattribute__(self,*args,**kwargs):
- print("__getattribute__()iscalled")
- returnobject.__getattribute__(self,*args,**kwargs)
- #return"haha"
- def__getattr__(self,name):
- print("__getattr__()iscalled")
- returnname+"fromgetattr"
- def__get__(self,instance,owner):
- print("__get__()iscalled",instance,owner)
- returnself
- def__getitem__(self,item):
- print('__getitem__call')
- returnobject.__getattribute__(self,item)
- deffoo(self,x):
- print(x)
- classC2(object):
- d=C()
- if__name__=='__main__':
- c=C()
- c2=C2()
- print(c.a)
- print(c.zzzzzzzz)
- c2.d
- print(c2.d.a)
- print(c['a'])
- 可以結合輸出慢慢理解，這里還沒涉及繼承關系呢。總之，每個以__get為前綴的方法都是獲取對象內部數據的鉤子，名稱不一樣，用途也存在較大的差異，只有在實踐中理解它們，才能真正掌握它們的用法。
四、__getitem__方法
如果僅僅想要對象能夠通過[]獲取對象屬性可以簡單的：
總結
當這幾個方法同時出現可能就會擾亂你了。我在網上看到一份示例還不錯，稍微改了下：
Ⅱ Python 獲取類屬性
通常情況下，我們在類對象中定義的屬性都會設置訪問許可權，外部程序無法直接獲取，防止惡意的修改，當屬性被設置為私有屬性後，外部程序該如何訪問呢？
例：使用普通方法訪問私有屬性
例：使用property方法訪問私有屬性
property()方法接收兩個參數，第一個參數為獲取屬性需要調用的實例方法名，第二個參數為設置屬性需要調用的實例方法名，返回值就設置為需要設置、獲取的屬性名。
當執行到實例.屬性時，就會調用獲取實例屬性的方法，當執行到實例.屬性 = xxx時，就會調用設置實例屬性的方法。
例：使用@property/@xxx.setter裝飾器訪問私有屬性
Ⅲ python中實例屬性和類屬性之間的關系
一般來說，在Python中，類實例屬性的訪問規則算是比較直觀的。
但是，仍然存在一些不是很直觀的地方，特別是對C++和Java程序員來說，更是如此。
在這里，我們需要明白以下幾個地方：
1.Python是一門動態語言，任何實體都可以動態地添加或刪除屬性。
2.一個類定義了一個作用域。
3.類實例也引入了一個作用域，這與相應類定義的作用域不同。
4.在類實例中查找屬性的時候，首先在實例自己的作用域中查找，如果沒有找到，則再在類定義的作用域中查找。
5.在對類實例屬性進行賦值的時候，實際上會在類實例定義的作用域中添加一個屬性（如果還不存在的話），並不會影響到相應類中定義的同名屬性。
下面看一個例子，加深對上述幾點的理解：
復制代碼
代碼如下:
class A:
cls_i = 0
cls_j
= {}
def __init__(self):
self.instance_i =
0
self.instance_j =
{}
在這里，我們先定義類A的一個實例a，然後再看看類A的作用域和實例a的作用域中分別有什麼：
復制代碼
代碼如下:
>>> a = A()
>>>
a.__dict__
{'instance_j': {}, 'instance_i': 0}
>>>
A.__dict__
{'__init__': , '__mole__': '__main__', 'cls_i': 0, 'cls_j': {},
'__doc__': None}
我們看到，a的作用域中有instance_i和instance_j，A的作用域中有cls_i和cls_j。
我們再來看看名字查找是如何發生的：
復制代碼
代碼如下:
>>> a.cls_i
0
>>>
a.instance_i
0
在查找cls_i的時候，實例a的作用域中是沒有它的，卻在A的作用域中找到了它；在查找instance_i的時候，直接可在a的作用域中找到它。
如果我們企圖通過實例a來修改cls_i的值，那會怎樣呢：
復制代碼
代碼如下:
>>> a.cls_i = 1
>>>
a.__dict__
{'instance_j': {}, 'cls_i': 1, 'instance_i': 0}
>>>
A.__dict__
{'__init__': , '__mole__': '__main__', 'cls_i': 0, 'cls_j': {},
'__doc__': None}
我們可以看到，a的作用域中多了一個cls_i屬性，其值為1；同時，我們也注意到A作用域中的cls_i屬性的值仍然為0；在這里，我們其實是增加了一個實例屬性，並沒有修改到類屬性。
如果我們通過實例a操縱cls_j中的數據（注意不是cls_j本身），又會怎麼樣呢：
復制代碼
代碼如下:
>>> a.cls_j['a'] =
'a'
>>> a.__dict__
{'instance_j': {}, 'cls_i': 1, 'instance_i':
0}
>>> A.__dict__
{'__init__': , '__mole__': '__main__',
'cls_i': 0, 'cls_j': {'a': 'a'}, '__doc__': None}
我們可以看到a的作用域沒有發生什麼變化，但是A的作用域發生了一些變化，cls_j中的數據發生了變化。
實例的作用域發生變化，並不會影響到該類的其它實例，但是類的作用域發生變化，則會影響到該類的所有實例，包括在這之前創建的實例：
復制代碼
代碼如下:
>>> A.cls_k = 0
Ⅳ python中類屬性的執行過程是什麼樣的
每輪調用都修改的是tool的count+=1，非這些對象的count += 1， 其實我也繞暈了，建議以後使用對象名調用類，類屬性，類方法，類裝飾器，這樣做不會吃虧的。
Ⅳ 如圖，python中類的屬性為啥有兩種不同的定義方式，同樣都是類的屬性，兩種有什麼區別
第一種：
上圖這種叫對象的屬性，只有在實例化類之後它們才能調用，如：
s = a(10,20,30) #實例化對象
print(s.lenght) #調用對象屬性
注意一點，類名需要大寫，然後你init裡面的少了self，而且init後面的lenght沒有意義。
Ⅵ python類中屬性方法的事件
1普通方法：直接用self調用的方法。
2私有方法：__函數名，只能在類中被調用的方法。
3屬性方法：@property，將方法偽裝成為屬性，讓代碼看起來更合理。
4特殊方法(雙下劃線方法)：以__init__為例，是用來封裝實例化對象的屬性，只要是實例化對象就一定會執行__init方法，如果對象子類中沒有則會尋找父類（超類），如果父類（超類）也沒有，則直接繼承object（python 3.x）類，執行類中的__init__方法。
5類方法：通過類名的調用去操作公共模板中的屬性和方法。
6靜態方法：不用傳入類空間、對象的方法， 作用是保證代碼的一致性，規范性，可以完全獨立類外的一個方法，但是為了代碼的一致性統一的放到某個模塊（py文件）中。