如何理解python的類與對象？

12-29

題主問的太籠統了,不知道答的對不對. 看下面的圖

左邊元類,中間類,右邊實例

其實記住的只是一點:python里一切都是對象,實例是對象,類是對象,元類也是對象.

這裡題主說的類和對象其實是包含和被包含的關係了.

那麼Python里的類和其他的對象有什麼區別?

實例是對象,因為創建實例的是類.類是對象,創建類的是什麼呢?Python給的答案就是元類.你可以通過type()函數來查看它的元類.(type(type)得到的是它自己)其實這個類和其他對象一樣,所以我們就不驚訝它為什麼有類方法,類變數了....

打個比方：

智能手機就是一個類（class），它是某類對象的統稱，而你手上的這部iPhone7就是從屬於智能手機這個類的一個具體實例／對象（object）。

智能手機都會有個電池容量的參數（智能手機這個類的域或類變數），智能手機的電池容量除以充電功率可得充滿電需要的時長（這一行為稱為智能手機這個類的方法）

具體到你的這部iPhone7也有它對應的電池容量（對象的域或實例變數），相應的：這部iPhone7的電池容量除以它的充電器功率也就得到它充滿電需要的時間（對象可調用從屬的那個類的方法）

再具體到張三的那部sumsung S7，同樣可以調用智能手機這個類的域和方法，得到那部S7的目標值。

事實上，先定義一個類（class），並初始化它的域和方法，然後從屬於它的具體對象（object）通過調用這個類的域和方法，即可得到目標值。這其實是模塊化設計的體現。

在具體對象較多時，先自定義一個類（或超類加子類的繼承類）封裝，然後各對象自行調用，可以高效地完成不同對象的目標實現（避免多個對象的重複代碼）

不知道這樣解釋行不行。

掛一個自己的學習筆記

這個時間一長就搞錯了，還經常回頭來看一看，尤其是self的用法。

python中一切皆為對象，所謂對象：我自己就是一個對象，我玩的電腦就是對象，坐著的椅子就是對象，家裡養的小狗也是一個對象。。。。。。

我們通過描述屬性（特徵）和行為來描述一個對象的。比如家裡的小狗，它的顏色，大小，年齡，體重等是它的屬性或特徵。它會汪汪叫，會搖尾巴等是它的行為。

我們在描述一個真實對象（物體）時包括兩個方面：

它可以做什麼（行為）

它是什麼樣的（屬性或特徵）。

在python中，一個對象的特徵也稱為屬性（attribute）。它所具有的行為也稱為方法（method）

結論：對象=屬性（特徵）+方法（行為）

類：在python中，把具有相同屬性和方法的對象歸為一個類（class）

比如人類，動物，植物等等，這些都是類的概念。

類是對象的模板或藍圖，類是對象的抽象化，對象是類的實例化。類不代表具體的事物，而對象表示具體的事物。

&>&>&> class people: #people就是類

... def speak(self):

... print ("hello!")

...

"""

定義一個people類，定義一個speak方法，但沒有定義屬性，

因為屬性不屬於類，而是屬於各個類的實例。也就是說屬於對象。

因此我們可以給每個實例設置不同的屬性

"""

&>&>&> class people: #類

... def speak(self): #方法

... print ("hello!")

...

&>&>&>

&>&>&> Thor = people() #創建Thor實例（對象）

&>&>&> Natasha= people() #創建Natasha實例

&>&>&> import tab #導入table鍵功能模塊

&>&>&> Thor. #輸入jack.，可以看到以下方法

Thor.__class__ Thor.__doc__ Thor.__module__ Thor.speak(

&>&>&> Thor.speak() #引用speak方法

hello!

&>&>&> Thor.age=39 #添加age屬性

&>&>&> Thor.h=190 #添加height屬性

&>&>&> Thor.

Thor.__class__ Thor.__module__ Thor.height

Thor.__doc__ Thor.age Thor.speak(

&>&>&> Thor.height

190

&>&>&> Thor.age

#初始化對象

創建類時，可以定義一個特定的方法，名為__init__(),只要創建這個類的一個實例就會運行這個方法。可以向__init__()方法傳遞參數，這樣創建對象時就可以把屬性設置為你希望的值。__init__()這個方法會在創建對象時完成初始化，"""

&>&>&> class peo:

def __init__(self,name,age,sex):

self.Name = name

self.Age = age

self.Sex = sex

def speak(self):

print ("my name" + self.Name)

實例化這個類的對象

&>&>&> zhangsan=peo("zhangsan",24,"male")

&>&>&> print (zhangsan.Age)

&>&>&> print (zhangsan.Name)

zhangsan

&>&>&> print (zhangsan.Sex)

male

# ----------

&>&>&> print(zhangsan)

&<__main__.peo object at 0x000001790B8BFE80&>

要讓print能列印出來，就得使用__str__方法

__str__()這個方法告訴python在列印(print)一個對象時,具體顯示什麼內容

"""

#! /usr/bin/python

&>&>&> class peo:

def __init__(self,name,age,sex):

self.Name = name

self.Age = age

self.Sex = sex

def speak(self):

print ("my name" + self.Name)

def __str__(self):

msg=("my name is: " +self.Name+ ","+ "my age is: " + self.Age +","+ "my sex is:" +self.Sex)

return msg

shanghai=peo("shanghai","23","man")

&>&>&> print(shanghai)

my name is: shanghai,my age is: 23,my sex is:man

此處23是年齡，但被轉成了字元串，因為self.Age定義的是字元串

如果不將23轉義，則會報錯

如果希望在程序中就事先轉義，需要使用str(self.Age)

"""

print shanghai

"""

之前多次用到self這個形參

類就好比是一張藍圖，使用一個類可以創建多個對象實例，

speak()方法在被調用時，必須知道是哪個對象調用了它.

這裡self參數就會告訴方法是哪個對象來調用的.這稱為實例引用。

zhangsan.speak()就好比寫成了peo.speak(zhangsan)

#道理說一萬遍，不如先嘗個栗子

直線長度

代碼

import math #調用math函數

class Point(): #定義點類

def __init__(self,x=0,y=0):

self.x=x

self.y=y

def getX(self):

return self.x

def getY(self):

return self.y

class Line(): #定義線類

def __init__(self,p1,p2):

self.x=p1.getX()-p2.getX()

self.y=p1.getY()-p2.getY()

self.len=math.sqrt(self.x*self.x+self.y*self.y)

def getLen(self):

return self.len

運行結果

&>&>&> p1=Point(1,1)

&>&>&> p2=Point(8,10)

&>&>&> line=Line(p1,p2)

&>&>&> line.getLen()

11.40175425099138

1.萬物皆對象,把對象歸類就有了類;

類也是對象,把類歸了類就是超類;

以此類推.

2.對象往往具備(也可以不具備) 行為和屬性.

行為我們通常用函數(function) 實現

屬性(attribute)我們通常用變數實現

3.因為萬物皆對象,所以"函數""變數"也是對象

所以 "變數"可以有自己的"函數", "函數"也可以有自己的變數.

4.藉此機會練習五筆,所以故意多打了一些字.

最近小結，望指點~

本人也是初學Python，在此談一下對類和對象的理解：

Python和VB一樣，都是面向對象編程（object oriented programming）的語言。所謂面向對象有三大特徵：封裝性、繼承性、多態性。

相信大家在問道類和對象之前已經了解到了Python強大的列表（list）。其實列表（list）就是所謂的類，這是所有你所創建的列表的統稱（如，list1，list2，隨便一個名字的列表，而你新建的這些具體的列表，就是對象）。這時大家應該抓住關鍵詞，相似對象的統稱為『類』（class），而『對象』(object)則是『類』的具體化.

另外，還想談一談屬性和方法，屬性可以看做是靜態特徵（外表看起來如何，定義的變數等），方法則是動態能力（能做什麼，定義的函數等），因此，再規範點來講就是：類是具有相似屬性和方法的對象的統稱，而對象則是滿足這些屬性和方法要求的不同個體。

舉一個簡單例子：『汽車』就是一個類，靜態特徵（屬性）是有四個輪子，動態能力（方法）是他能跑；而某人的一輛瑪莎拉蒂（具有自己的車牌號，獨一無二），他不但有四個輪子，也能跑。我覺得這應該也稱得上是『繼承性』。

但更多人，談到繼承性，更樂意用子類和父類（也叫基類、超類）的概念，當然從名字就能看出歸屬問題了。對於父類屬性和方法的定義，子類不需要再重新定義，就可以直接調用父類的方法（如果重新定義-相同的函數名（稱為『重載』，是多態性的體現），新的定義會覆蓋掉原有定義，當然只是在子類中，對父類沒有影響）。

不足之處還請指教，希望能對大家的學習有所幫助。

類就是藍圖，對象就是用這圖建造出來的玩意兒，不知道我這樣理解對不對

程序是對現實世界的模擬，那麼我們先抽象出世界的模型，在這個模型里世界是由對象構成，我們在抽象一下，發現對象由行為，屬性構成，再抽象一下就是類了！

（也許是史上）最直白的Python類（class）和對象（object）講解 - 知乎專欄

個人經驗，僅供參考。

當年，這個類和對象差點兒把我整瘋了，後來看了：

公開課，太原理工大學《面向對象編程思想概覽》，

書，a byte of python，（雖然寫的很簡單，但總算讓我明白了）。

這才明白什麼類，什麼對象，及python面向對象這部分內容。

-這是分割線-

當年我直接看的《python學習手冊》，個人感覺，面向對象部分寫的並不好。

一般的OOP思想，類是對象的模板，對象是類的實例，對象才具有行為和屬性。

但是Python中的類要特殊一點，它也是一種對象，不過是一種較為特殊的對象，它可以創造其他對象，而用來創建Python中類這種對象的類被稱為元類。

附上一篇好文章：

深刻理解Python中的元類http://python.jobbole.com/21351/

生活中總是會遇到很多 SB，我們把 SB_A、SB_B、SB_C 統一歸類為 SB，SB 這個詞，這一類人的合稱，就相當於 Python 中的類。

SB_A、SB_B、SB_C 等花樣繁多、內涵各異、各式各樣的 SB，單個拎出來，也都是 SB，但是因為是單個的，鮮活的，是 SB 的典型實例，是類的實例，就相當於 Python 中的對象，不過，誰會希望自己的對象是 SB 呢？

：對象是類的實例。

：SB_A 是 SB 的例子。

：SB_B 是 SB 的例子。

：SB_C 是 SB 的例子。

……

SB 怎麼這麼多？

SB 總是有屬性的，比如可能是男的，可能是女的。

SB 總是有方法的，總是有各種辦法讓你不爽。

以下請自由發揮。

寫這個回答的時候，我的耳邊環繞著德國兒歌 Schnappi 。

著作權歸作者所有。

商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。

作者：buptlinlinlin

鏈接：python類、對象、方法、屬性之類與對象

來源：CSDN博客

python中一切皆為對象，所謂對象：我們自己就是一個對象，我們玩的電腦就是對象，坐著的椅子就是對象，家裡養的小狗也是一個對象...
我們通過描述屬性（特徵）和行為來描述一個對象的。比如家裡的小狗，它的顏色，大小，年齡，體重等是它的屬性或特徵。它會汪汪叫，會搖尾巴等是它的行為。
我們在描述一個真實對象（物體）時包括兩個方面：
1.它可以做什麼（行為）
2.它是什麼樣的（屬性或特徵）。
在python中，一個對象的特徵也稱為屬性（attribute）。它所具有的行為也稱為方法（method）
結論：對象=屬性+方法
在python中，把具有相同屬性和方法的對象歸為一個類（class）
比如人類，動物，植物等等，這些都是類的概念。
類是對象的模板或藍圖，類是對象的抽象化，對象是類的實例化。類不代表具體的事物，而對象表示具體的事物。
&>&>&> class people:
... def speak(self):
... print ("hello!")
...
"""
定義一個people類，定義一個speak方法，但沒有定義屬性，
因為屬性不屬於類，而是屬於各個類的實例。也就是說屬於對象。
因此我們可以給每個實例設置不同的屬性
"""
&>&>&> class people: #類
... def speak(self): #方法
... print ("hello!")
...
&>&>&>
&>&>&> jack = people() #創建jack實例
&>&>&> tom = people() #創建tom實例
&>&>&> import tab #導入table鍵功能模塊
&>&>&> jack. #輸入jack.&，可以看到以下方法
jack.__class__ jack.__doc__ jack.__module__ jack.speak(
&>&>&> jack.speak() #引用speak方法
hello!
&>&>&> jack.age=39 #添加age屬性
&>&>&> jack.h=120 #添加height屬性
&>&>&> jack.
jack.__class__ jack.__module__ jack.height
jack.__doc__ jack.age jack.speak(
&>&>&> jack.height
120
&>&>&> jack.age
39
"""
#初始化對象
創建類時，可以定義一個特定的方法，名為__init__(),只要創建這個類的一個實例
就會運行這個方法。可以向__init__()方法傳遞參數，
這樣創建對象時就可以把屬性設置為你希望的值
__init__()這個方法會在創建對象時完成初始化，
"""
&>&>&> class peo:
... def __init__(self,name,age,sex):
... self.Name = name
... self.Age = age
... self.Sex = sex
... def speak(self):
... print "my name" + self.Name
...
&>&>&>
實例化這個類的對象時：
&>&>&> zhangsan=peo("zhangsan",24,"man")
&>&>&> print zhangsan.Age
24
&>&>&> print zhangsan.Name
zhangsan
&>&>&> print zhangsan.Sex
man
# ----------
&>&>&> print zhangsan
&<__main__.peo instance at 0x7fe5041ec248&>
"""
要讓print能列印出來，就得使用__str__方法
__str__()這個方法告訴python在列印(print)一個對象時,具體顯示什麼內容
"""
#! /usr/bin/python
class peo:
def __init__(self,name,age,sex):
self.Name = name
self.Age = age
self.Sex = sex
def speak(self):
print "my name" + self.Name
def __str__(self):
msg="my name is: " +self.Name+ ","+ "my age is: " + self.Age +","+ "my sex is:" +self.Sex
# msg="my name is: " +self.Name+ ","+ "my age is: " + str(self.Age) +","+ "my sex is:" +self.Sex
return msg
shanghai=peo("shanghai","23","man")
# shanghai=peo("shanghai",23,"man")
"""
msg="my name is: " +self.Name+ ","+ "my age is: " + self.Age +","+ "my sex is:" +self.Sex
此處23是年齡，但被轉成了字元串，因為self.Age定義的是字元串
如果不將23轉義，則會報錯
如果希望在程序中就事先轉義，需要使用str(self.Age)
"""
print shanghai
"""
之前多次用到self這個形參
類就好比是一張藍圖，使用一個類可以創建多個對象實例，
speak()方法在被調用時，必須知道是哪個對象調用了它.
這裡self參數就會告訴方法是哪個對象來調用的.這稱為實例引用。
zhangsan。speak()就好比寫成了peo.speak(zhangsan)
"""

去學java就懂了

類，是一種可以將數據和方法按需要綁在一起，設定相應的邏輯，甚至在內部抽象出更高級的東西，然後將它們封裝在一起，形成的一個模版。實例就是按照模版的格式新建一個數據。而你說的對象其實是有點籠統了，希望問得明白些