python的類的屬性

⑴ python 類屬性為類時，如何進行賦值

因為b.name[0]
=
'zhang'修改的是類屬性,類屬性是全局的,所有的實例共享,如果想私有化,可以添加
def
__init__(
self
):
self.name
=
list(
self.name
)
就可以了.

⑵ python 繼承與類屬性的使用

題主的注釋是沒有問題的。
子類繼承父類後，會自動繼承了父類的屬性。如果在子類中修改了繼承得來的類屬性時（即B.count=200），並不會修改父類的對應的同名類屬性（A.count）。以後只要是通過子類訪問該屬性，訪問的都是子類的屬性。
通過父類修改了父類屬性後，子類訪問該屬性時，會訪問父類修改後的屬性值。當然前提是子類沒有對該屬性重新賦值過。

⑶ python中類屬性和類實例的屬性的區別taoCMS

今天一同事說踩了python的坑， 這確實是個「坑」

但是我覺得python之所以這樣設計，就是明確要求寫代碼的人知道自己在寫什麼^ ^

python的實例屬性必須在__init__(self) 方法中定義，直接跟在類名後邊定義的屬性都默認是類屬性(類似於c++的static變數)。

而python實例又可以靈活的隨便增加屬性，便出現了圖片中看似詭異的現象。

---------------------------------

我們來看一下他的原代碼：

你覺得輸出會是什麼？

結果是 model_path 分別是 "xx_model" 和 "oo_model"

而model_dict全都是第二次調用的結果，也就是oo_model生成的dict的值（注意，他前邊有一句self.model_dict.clear() ）

原因是什麼呢？ "坑" 就在 他是用self.xxxx 這種方式引用變數，而不是self.__class__.xxxx

(1) self.model_path=path; #這對self.model_path進行了賦值，python中的第一次賦值視為變數的定義！

(2) self.xxxx這種格式的第一次賦值含義是什麼呢？-->含義是：定義，也就是說定義了一個名為xxxx的實例屬性。

(3) 因此m1,m2的兩次調用，分別定義了對應的(不同的)self.model_path屬性。

而self.model_dict，從頭到尾都是 引用 它，從未進行過 賦值(重定義)，所以引用的都是 類屬性

⑷ python 里的屬性是什麼意思

Python是面向對象的語言，在python中一切皆對象
對象就是你要腳本或程序中的變數、類、函數。。。
每個對象有自己的屬性，比如一個函數有自己的形參、邏輯運算之類的。
類這個概念和C中的結構體差不多，就是定義一組對象，有一個固定的屬性，然後將類實例化，就是繼承這個類的所有屬性。
方法其實就是函數，你處理對象用的手段。

⑸ 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類的屬性有哪幾種如何訪問它們

屬性的訪問機制

一般情況下，屬性訪問的默認行為是從對象的字典中獲取，並當獲取不到時會沿著一定的查找鏈進行查找。例如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)

• 其他情況見文末參考資料的文檔

四、__getitem__方法

• 這個調用也屬於無條件調用，這點與__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為前綴的方法都是獲取對象內部數據的鉤子，名稱不一樣，用途也存在較大的差異，只有在實踐中理解它們，才能真正掌握它們的用法。

⑼ python 類中的私有屬性有哪些

類的私有屬性：
__private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類地外部被使用或直接訪問。
在類內部的方法中使用時 self.__private_attrs。

類的方法:
在類地內部，使用def關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數self,且為第一個參數

類的私有方法 :
__private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。
在類的內部調用 self.__private_methods

實例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
__secretCount = 0 # 私有變數
publicCount = 0 # 公開變數

def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 報錯，實例不能訪問私有變數

Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性，將如下代碼替換以上代碼的最後一行代碼：
…………………….
print counter._JustCounter__secretCount

這樣就可以訪問私有屬性了

⑽ python類中的 方法 屬性分別什麼意思

就比方說有一個類叫做car

這個類的屬性可以有colorsizebrandpriceyear等描述性的東西

這個類的方法可以是runstopforwardbackward等執行性的東西

classcar:
#定義基本屬性
color=''
size=0
brand=''
price=0
year=0

#定義構造方法
def__init__(self):
self.color=color
self.size=size
self.brand=brand
self.price=price
self.year=year
defrun(self):
print("thecarisrunning")
defstop(self):
print("thecarisstop")
defforward(self):
print("thecarisforward")
defbackward(self):
print("thecarisbackward")

#類調用

benz=car('red',1.8T,'Mercedes',400000,2016)
benz.run()
benz.stop()
benz.forward()
benz.backward()