python對象的屬性

『壹』 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()

『貳』 python怎麼定義對象屬性

就比方說 有一個類 叫做 car 這個類的屬性 可以有 color size brand price year 等描述性的東西 這個類的方法 可以是 run stop forward backward 等執行性的東西 class car: #定義基本屬性 color = '' size = 0 brand = '' price = 0 year = 0 #...

『叄』 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 編程中 什麼叫對象的屬性 是對應的數字嗎

classPerson:
def__init__(self,name,surname):
print'Apersonhasbeenborn...'
self.name=name
self.surname=surname
defgreet(self):
print'Hello,mynameis%s%s.'%(self.name,self.surname)

p1=Person('Jim','Green')
p1.greet()

Python支持面向對象編程，給你個簡單的例子，上面這個類叫Person，這個類就是一個對象，我定義這個類的時候有name，surname，這兩個就是它的屬性，所以你調用這個類的時候一定要給屬性賦值，greet是類裡面定義的函數，你可以自己調用，__init__是定義類必須要求的。

『伍』 python什麼是類,對象,實例

類和對象
對象是什麼？

對象=屬性（靜態）+方法（動態）；

屬性一般是一個個變數；方法是一個個函數；

#類的屬性 就是 類變數

#實例變數：定義在方法中的變數，只作用於當前實例的類。

例子：

class Turtle:#python 中類名約定以大寫字母開頭
'''關於類的簡單例子。。。'''
#屬性 == 類變數
color ="green"
weight="10kg"
legs=4
shell=True
mouth='big'
#方法
def climb(self):
self.name = "test" #實例變數：定義在方法中的變數，只作用於當前實例的類。
print("我在很努力爬。")
def run(self):
print('我在很努力跑。')
def bite(self):
print('我要要要要要')
def sleep(self):
print('我要睡覺啦。')
#創建一個實例對象也就是類的實例化！
tt =Turtle() #類的實例化，也就是創建一個對象，類名約定大寫字母開頭
tt.bite() #創建好類後就能調用類裡面的方法叻；
tt.sleep()

『陸』 python怎麼判斷一個對象的屬性

方法一：通過異常捕捉來實現邏輯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class FooClass:

pass

k = FooClass()

try:

#do some thing you need

print k.att

except AttributeError as e:

#error: has not attribute

pass

方法二：調用hasattr方法
hasattr(object, name)
說明：判斷對象object是否包含名為name的特性（hasattr是通過調用getattr(ojbect, name)是否拋出異常來實現的）。
參數object：對象。
參數name：特性名稱。
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False
方法三：使用dir方法
objlist = dir(k)
if 'att' in objlist:
#do some thing you need
print k.att
else:
#error: has not attribute

pass

『柒』 如圖，python中類的屬性為啥有兩種不同的定義方式，同樣都是類的屬性，兩種有什麼區別

第一種：

上圖這種叫對象的屬性，只有在實例化類之後它們才能調用，如：
s = a(10,20,30) #實例化對象

print(s.lenght) #調用對象屬性

注意一點，類名需要大寫，然後你init裡面的少了self，而且init後面的lenght沒有意義。

『捌』 怎麼判斷 Python 對象是否包含某個屬性

頂級函數hasattr可以查看對象是否包含某某屬性，這里的屬性包括數據屬性和方法。getattr可以獲取屬性。

如下舉例說明。

a=[1,2,3]
print('列表有count屬性:%s'%hasattr(a,'count'))
print('列表有append屬性:%s'%hasattr(a,'append'))
print('列表有shift屬性:%s'%hasattr(a,'shift'))
print('列表的count屬性是方法:%s'%hasattr(getattr(a,'count'),'__call__'))
print('列表的append屬性是方法:%s'%hasattr(getattr(a,'append'),'__call__'))
classmyclass():
def__init__(self):
self.valattr=3
defmethod(self):
pass
mc=myclass()
print('myclass有valattr屬性:%s'%hasattr(mc,'valattr'))
print('myclass有method屬性:%s'%hasattr(mc,'method'))
print('myclass的valattr屬性是方法:%s'%hasattr(getattr(mc,'valattr'),'__call__'))
print('myclass的method屬性是方法:%s'%hasattr(getattr(mc,'method'),'__call__'))

『玖』 如何理解關於python 面向對象的特性

python中一切皆為對象
其實面向對象沒什麼高大上的東西，只不過把我們平時對於事物的描述和動作系統的總結成了一個定義事物的方法而已。
我們平時向別人介紹一個他（她）從未見過的東西，會從外形和外貌特徵來說明這個東西，比如顏色，大小等，這就對象的屬性。還會介紹這個東西能做什麼或者有什麼用，這就是對象的方法。所以用屬性和方法就可以定義一個對象。也就是說一個對象包含了各種屬性和方法。
在python中使用對象屬性和方法的記法為：object.attribute 或 object.method()
Python中創建對象的第一步是建立一個類（class），這個類就類似於我們區分動物和植物。動物類和植物類各有自己的特徵，當我們見到一個事物時，如果它滿足動物的特徵，我們就說它是動物；如果它滿足植物的特徵，那麼它就屬於植物。同樣的當我們在python中建立一個類時，就要說名這個類的屬性有什麼，方法有什麼。然後再創建屬於這個類的具體實例，也就是對象。那麼這個對象也就有了這個類的屬性和方法。但具體的屬性和方法根據具體對象而定。就像動物類的屬性就是有耳朵，有眼睛，有皮毛，方法就是移動，進食等等，具體對象比如說是兔子那就是有長長的耳朵，紅色的眼睛，白色的皮毛。方法就是奔跑，進食就是吃胡蘿卜。這樣理解類和對象或者實例就沒什麼抽象的了。
__init__(): 創建類的默認屬性，也稱初始化
__str__() : 返回對象的字元串表達式
多態：對於不同的類可以有同名的方法，同名的方法應用到不同的類可以有不同的行為。
形如：
class Triangle:
def __init__(self, width,height):
self.width = width
self.height = height
def getArea(self):
area = self.width * self.height / 2.0
return area
class Square:
def __init__(self,size):
self.size = size
def getArea(self):
area = self.size * self.size
return area
繼承：類可以從其他類繼承屬性和方法；從其他類繼承屬性或方法稱為派生類或者子類。
形如：class Animal:
def __init__(self,name):
self.name = name
class Dog(Animal):
def __init__(self,color):
self.color = color
def runSpeed():
pass
這樣Dog就繼承了Animal的name屬性。
對象的方法代碼暫未想出可以用pass佔位。

『拾』 Python中的類屬性和對象屬性的區別詳解

類屬性：
class Employee(object):
emCount=0
def __init__(self,name,salary):
self.nane=name
self.salary=salary
類屬性就是定義類的時候直接定義的屬性 emCount，類似於java裡面的static修飾的屬性，可以直接通過 類名.屬性名訪問：Employee.emCount
實例屬性是在__init()方法中定義的屬性，例如name，和salary,self是指向自己的，類似java的this關鍵字，實際是通過內置的方法setattr()完成的
可以通過重寫setatttr()進行類屬性的增加和獲取