前言

本文從代碼復(fù)用的角度一步一步演示如何從python普通代碼進(jìn)化到面向?qū)ο?，并通過代碼去解釋一些面向?qū)ο蟮睦碚?。所以，本文前面的?nèi)容都是非面向?qū)ο蟮恼Z(yǔ)法實(shí)現(xiàn)方式，只有在最結(jié)尾才給出了面向?qū)ο蟮暮?jiǎn)單語(yǔ)法介紹。各位道兄不妨一看，如果留下點(diǎn)筆墨指導(dǎo)，本人感激不盡。

下面話不多說了，來一起看看詳細(xì)的介紹吧

最初代碼

3種動(dòng)物牛Cow、羊Sheep、馬Horse發(fā)出的聲音各不相同，于是在同一個(gè)目錄下建立三個(gè)模塊文件：

$ tree .
.
|-- cow.py
|-- horse.py
`-- sheep.py

三個(gè)模塊文件的內(nèi)容都只定義了各自的speak()函數(shù)：

# cow.py
def speak():
 print("a cow goes moooo!")

# sheep.py
def speak():
 print("a sheep goes baaaah!")

# horse.py
def speak():
 print("a horse goes neigh!")

然后當(dāng)前目錄下在創(chuàng)建一個(gè)程序文件main.py，導(dǎo)入這三個(gè)模塊文件，分別調(diào)用這三種動(dòng)物的speak()函數(shù)，它們將發(fā)出不同聲音：

# main.py
import cow,sheep,horse

cow.speak()
sheep.speak()
horse.speak()

讓代碼更具共性的兩種基本方法

上面的cow.py、sheep.py和horse.py中，都是speak()函數(shù)，不同的是函數(shù)內(nèi)容，確切地說是函數(shù)內(nèi)容中print()輸出的部分不同，它們輸出的結(jié)構(gòu)是a 動(dòng)物名 goes 叫聲!。于是為了讓代碼更具共性，或者說復(fù)用性更高，可以將各模塊文件中的動(dòng)物名和叫聲都變得通用化。

目前來說，有兩種最基本的方式可以讓一段代碼變得更共性、共通用化：使用參數(shù)或變量、使用額外的輔助函數(shù)。當(dāng)然，除此之外還有更多的方法，但目前來說這兩種是最基本的，也是最容易理解的。

使用參數(shù)(變量)讓代碼更具共性

首先讓動(dòng)物名變得共性化?？梢宰宻peak()中的動(dòng)物名使用一個(gè)參數(shù)來替代。例如名為self的參數(shù)變量(之所以使用self，是因?yàn)樵诿嫦驅(qū)ο笾兴刑厥夂x，后文解釋)，于是修改這三個(gè)模塊文件：

# cow.py
def speak(self):
 print("a %s goes moooo!" % (self))

# sheep.py
def speak(self):
 print("a %s goes baaaah!" % (self))

# horse.py
def speak(self):
 print("a %s goes neigh!" %(self))

它們現(xiàn)在在動(dòng)物名上和參數(shù)名上已經(jīng)完全相同，需要調(diào)用它們時(shí)，只需在函數(shù)調(diào)用處為他們傳遞不同的動(dòng)物名即可。例如，在main.py中：

import cow,sheep,horse

cow.speak("cow")
sheep.speak("sheep")
horse.speak("horse")

使用輔助函數(shù)讓代碼更具共性

除了參數(shù)(變量)，還可以定義額外的函數(shù)來上面的代碼變得更具共性。例如，這三種動(dòng)物的叫聲，可以額外定義一個(gè)sound()函數(shù)描述它們。于是在前面的基礎(chǔ)上繼續(xù)修改這三個(gè)模塊文件：

# cow.py
def speak(self):
 print("a %s goes %s!" % (self,sound()))

def sound():
 return "moooo"

# sheep.py
def speak(self):
 print("a %s goes %s!" % (self,sound()))

def sound():
 return "baaaah"

# horse.py
def speak(self):
 print("a %s goes %s!" % (self,sound()))

def sound():
 return "neigh"

在main.py中，仍然可以使用之前的方式對(duì)這3個(gè)speak()進(jìn)行調(diào)用：

import cow,sheep,horse

cow.speak("cow")
sheep.speak("sheep")
horse.speak("horse")

現(xiàn)在，這3個(gè)模塊文件的speak()已經(jīng)完完全全地共性化了。

初步理解類和對(duì)象

所謂的類，就像是一個(gè)模板；所謂對(duì)象，就像是通過模板生成的具體的事物。類一般具有比較大的共性，對(duì)象一般是具體的，帶有自己的特性。

類與對(duì)象的關(guān)系，例如人類和人，鳥類和麻雀，交通工具和自行車。其中人類、鳥類、交通工具類都是一種類型稱呼，它們中的任何一種都具有像模板一樣的共性。例如人類的共性是能說話、有感情、雙腳走路、能思考等等，而根據(jù)這個(gè)人類模板生成一個(gè)人，這個(gè)具體的人是人類的實(shí)例，是一個(gè)人類對(duì)象，每一個(gè)具體的人都有自己的說話方式、感情模式、性格、走路方式、思考能力等等。

類與類的關(guān)系。有的類的范疇太大，模板太抽象，它們可以稍微細(xì)化一點(diǎn)，例如人類可以劃分為男性人類和女性人類，交通工具類可以劃分為燒油的、電動(dòng)的、腳踏的。一個(gè)大類按照不同的種類劃分，可以得到不同標(biāo)準(zhǔn)的小類。無論如何劃分，小類總是根據(jù)大類的模板生成的，具有大類的共性，又具有自己的個(gè)性。

在面向?qū)ο笾校☆惡痛箢愔g的關(guān)系稱之為繼承，小類稱之為子類，大類稱之為父類。

類具有屬性，屬性一般包括兩類：像名詞一樣的屬性，像動(dòng)詞一樣的行為。例如，人類有父母(parent)，parent就是名詞，人類能吃飯(eat)，eat這種行為就是動(dòng)詞。鳥類能飛(fly)，fly的行為就是動(dòng)詞，鳥類有翅膀(wing)，wing就是名詞。對(duì)于面向?qū)ο髞碚f，名詞就是變量，動(dòng)詞行為就是方法(也就是子程序)。通常，變量和方法都成為類的屬性。

當(dāng)子類繼承了父類之后，父類有的屬性，子類可以直接擁有。因?yàn)樽宇愐话憔哂凶约旱膫€(gè)性，所以子類可以定義自己的屬性，甚至修改從父類那里繼承來的屬性。例如，人類中定義的eat屬性是一種非常抽象的、共性非常強(qiáng)的動(dòng)詞行為，如果女性人類繼承人類，那么女性人類的eat()可以直接使用人類中的eat，也可以定義自己的eat(比如淑女地吃)覆蓋從人類那里繼承來的eat(沒有形容詞的吃)，女性人類還可以定義人類中沒有定義的跳舞(dance)行為，這是女性人類的特性。子類方法覆蓋父類方法，稱之為方法的重寫(override)，子類定義父類中沒有的方法，稱為方法的擴(kuò)展(extend)。

當(dāng)通過類構(gòu)造出對(duì)象后，對(duì)象是類的實(shí)例，是類的具體化，對(duì)象將也具備類的屬性，且對(duì)象的屬性都有各自的值。例如，student類具有成績(jī)、班級(jí)等屬性，對(duì)于一個(gè)實(shí)際的學(xué)生A對(duì)象來說，他有成績(jī)屬性，且這個(gè)成績(jī)具有值，比如89分，班級(jí)也一樣，比如2班，此外，學(xué)生B也有自己的成績(jī)和班級(jí)以及對(duì)應(yīng)的值。也就是說，根據(jù)類模板生成對(duì)象后，對(duì)象的各個(gè)屬性都屬于自己，不同對(duì)象的屬性互不影響。

無論是對(duì)象與類還是子類與父類，它們的關(guān)系都可以用一種"is a"來描述，例如"自行車 is a 交通工具"(對(duì)象與類的關(guān)系)、"筆記本 is a 計(jì)算機(jī)"(子類與父類的關(guān)系)。

繼承

回到上面的3個(gè)模塊文件。它們具有共性的speak()和sound()，盡管sound()的返回內(nèi)容各不相同，但至少函數(shù)名sound是相同的。

可以將這3個(gè)文件中共性的內(nèi)容抽取到同一個(gè)模塊文件中，假設(shè)放進(jìn)animal.py的文件中。animal.py文件的內(nèi)容為(但這是錯(cuò)誤的代碼，稍后修改)：

def speak(self):
 print("a %s goes %s!" % (self,sound()))

def sound(): pass

然后修改cow.py、sheep.py和horse.py，使它們"繼承"animal.py。

# cow.py
import animal

def sound(): return "moooo"

# sheep.py
import animal

def sound(): return "baaaah"

# horse.py
import animal

def sound(): return "neigh"

現(xiàn)在，這三個(gè)模塊文件都沒有了speak()，因?yàn)樗鼈兌冀栌盟鼈兊?父類"animal中的speak()。

這表示horse、cow和sheep"繼承"了animal，前三者為"子類"，后者為"父類"。

但注意，這里不是真正的繼承，因?yàn)閜ython不支持非class對(duì)象的繼承，所以沒法通過非面向?qū)ο笳Z(yǔ)法演示繼承。但至少?gòu)拇a復(fù)用的角度上來說，它和繼承的功能是類似的。

另外注意，前面animal.py文件是錯(cuò)誤的，因?yàn)樗膕peak()函數(shù)中調(diào)用了sound()函數(shù)，但sound()函數(shù)在animal.py中是一個(gè)沒任何用處的函數(shù)，僅僅只是代表這個(gè)animal具有sound()功能(表示類的一個(gè)屬性)。而我們真正需要的sound()是可以調(diào)用cow、horse、sheep中的sound()，而不是animal自身的sound()。

所以，在沒有使用面向?qū)ο笳Z(yǔ)法的情況下，改寫一下animal.py文件，導(dǎo)入cow、horse、sheep，使得可以在"父類"的speak()中調(diào)用各個(gè)"子類"的sound()。再次說明，這里只是為了演示，這種編程方式是不規(guī)范的，在真正的面向?qū)ο笳Z(yǔ)法中根本無需這些操作。

以下是修改后的animal.py文件：

import cow,horse,sheep

def speak(self):
 print( "a %s goes %s!" % (self, eval(self + ".sound()")) )

def sound(): 
 pass

上面使用eval函數(shù)，因?yàn)閜ython不支持普通的變量名作為模塊名來調(diào)用模塊的屬性sound()，所以使用eval先解析成cow或horse或sheep，再調(diào)用各自的sound()函數(shù)。如果不懂eval()的功能，可無視它。只需知道這是為了實(shí)現(xiàn)self.sound()來調(diào)用self所對(duì)應(yīng)變量的sound()函數(shù)。

現(xiàn)在，在main.py中，使用下面的代碼來調(diào)用speak()，得到的結(jié)果和前面是一樣的。

import cow,sheep,horse

cow.animal.speak("cow")
sheep.animal.speak("sheep")
horse.animal.speak("horse")

由于不是真正的"繼承"，所以這里只能通過模塊的方式添加一層animal.來調(diào)用speak()。

雖然上面的代碼變得"人不人鬼不鬼"(因?yàn)闆]有使用面向?qū)ο蟮恼Z(yǔ)法)，但面向?qū)ο蟮幕灸繕?biāo)達(dá)到了：共性的代碼全部抽取出去，實(shí)現(xiàn)最大程度的代碼復(fù)用。

self是什么

在python的面向?qū)ο笳Z(yǔ)法中，將會(huì)經(jīng)?？匆妔elf這個(gè)字眼。其實(shí)不僅python，各種動(dòng)態(tài)類型的、支持面向?qū)ο蟮恼Z(yǔ)言都使用self，例如perl、ruby也是如此。但是，self是約定俗成的詞，并非是強(qiáng)制的，可以將self換成其它任何字符，這并不會(huì)出現(xiàn)語(yǔ)法錯(cuò)誤。

實(shí)際上，對(duì)于靜態(tài)面向?qū)ο笳Z(yǔ)言來說，用的更多的可能是this，比如java、c#、c++都使用this來表示實(shí)例對(duì)象自身。

那么self到底是什么東西？

在前文，為了將cow、sheep和horse模塊中speak()函數(shù)中的動(dòng)物名稱變得共性，添加了一個(gè)self參數(shù)。之前的那段代碼如下：

# cow.py
def speak(self):
 print("a %s goes moooo!" % (self))

# sheep.py
def speak(self):
 print("a %s goes baaaah!" % (self))

# horse.py
def speak(self):
 print("a %s goes neigh!" %(self))

當(dāng)調(diào)用這三個(gè)函數(shù)時(shí)，分別傳遞各自的動(dòng)物名作為參數(shù)：

import cow,sheep,horse

cow.speak("cow")
sheep.speak("sheep")
horse.speak("horse")

所以，對(duì)于cow來說，self是名為"cow"的動(dòng)物，對(duì)于sheep來說，self是名為"sheep"的動(dòng)物，對(duì)于horse來說，self是名為"horse"的動(dòng)物。

也就是說，self是各種動(dòng)物對(duì)象，cow.speak()時(shí)是cow，sheep.speak()時(shí)是sheep，horse.speak()時(shí)是horse。這里的模塊名變量和speak()的參數(shù)是一致的，這是我故意設(shè)計(jì)成這樣的，因?yàn)槊嫦驅(qū)ο笳Z(yǔ)法中默認(rèn)的行為和這是完全一樣的，僅僅只是因?yàn)檎Z(yǔ)法不同而寫法不同。

簡(jiǎn)而言之，self是各個(gè)動(dòng)物對(duì)象自身。

后來將cow、sheep和horse的speak()函數(shù)抽取到了animal中，仍然使用self作為speak()的參數(shù)。

以下是animal.py文件中的speak()函數(shù)：

def speak(self):
 print( "a %s goes %s!" % (self, eval(self + ".sound()")) )

當(dāng)使用下面的方式去調(diào)用它時(shí)：

cow.animal.speak("cow")
sheep.animal.speak("sheep")
horse.animal.speak("horse")

self是cow、是sheep、是horse，而不是animal。前面說了，在真正的面向?qū)ο笳Z(yǔ)法中，中間的這一層animal是被省略的，這里之所以加上一層animal，完全是因?yàn)閜ython的非面向?qū)ο笳Z(yǔ)法中沒辦法實(shí)現(xiàn)繼承。

當(dāng)真正使用面向?qū)ο笳Z(yǔ)法的時(shí)候，self將表示實(shí)例對(duì)象自身。例如student類有name屬性，當(dāng)根據(jù)此類創(chuàng)建一個(gè)stuA對(duì)象，并使用self.name時(shí)，表示stuA.name，換句話說，self是stuA這個(gè)對(duì)象自身，self.name是stuA對(duì)象自身的屬性name，和另一個(gè)學(xué)生對(duì)象的stuB.name無關(guān)。

重寫父類方法

前面的animal.py中定義了一個(gè)空代碼體的sound()函數(shù)，在cow、sheep和horse中定義了屬于自己叫聲的sound()函數(shù)。這其實(shí)就是方法的重寫(方法就是函數(shù)，只是在面向?qū)ο笾蟹Q為方法)：父類定義了某個(gè)方法，子類修改和父類同名的方法。

例如，新添加一個(gè)類mouse，重寫animal的speak()方法，mouse的speak()方法中會(huì)叫兩聲，而不是其它動(dòng)物一樣只有一聲。假設(shè)mouse類定義在mouse.py文件中，代碼如下：

import animal

def speak(self):
 animal.speak(self)
 print(sound())

def sound():
 return "jijiji"

這里重寫了父類animal的speak()，并在mouse.speak()中調(diào)用了父類animal.speak()，再次基礎(chǔ)上還叫了一聲。

為了讓這段代碼運(yùn)行，需要在animal.py中導(dǎo)入mouse，但在真正面向?qū)ο笳Z(yǔ)法中是不需要的，原因前面說了。

# animal.py
import cow,horse,sheep,mouse

def speak(self):
 print( "a %s goes %s!" % (self, eval(self + ".sound()")) )

def sound(): 
 pass

然后在main.py中調(diào)用mouse.speak()即可：

import cow,sheep,horse,mouse

cow.animal.speak("cow")
sheep.animal.speak("sheep")
horse.animal.speak("horse")
mouse.speak("mouse")

按照"里氏替換原則"：子類重寫父類方法時(shí)，應(yīng)該擴(kuò)展父類的方法行為，而不是直接否定父類的方法代碼并修改父類方法的代碼。這是一種編程原則，并非強(qiáng)制，但是經(jīng)驗(yàn)所在，我們應(yīng)當(dāng)參考甚至盡量遵循這些偉人提出的原則。

正如上面的mouse，speak()是在父類的speak()上擴(kuò)展的。如果將mouse.speak()改為如下代碼，則不符合里氏替換原則：

import animal

def speak(self):
 print(sound())
 print(sound())

def sound():
 return "jijiji"

并非一定要遵循里氏替換原則，應(yīng)該根據(jù)實(shí)際場(chǎng)景去考慮。比如上面的sound()方法，父類的sound()是一個(gè)空方法，僅僅只是聲明為類的屬性而存在。子類可以隨意根據(jù)自己的類特性去定制sound()。

再舉一個(gè)擴(kuò)展父類方法的例子。在父類中定義了一個(gè)clean()方法，用于清理、回收父類的一些信息。子類中也重寫一個(gè)clean()方法，但這時(shí)應(yīng)當(dāng)確保子類的clean()中包含了調(diào)用父類的clean()方法，再定義屬于子類獨(dú)有的應(yīng)當(dāng)清理的一些信息。這就是父類方法的擴(kuò)展，而不是父類方法的直接否定。因?yàn)樽宇惒⒉恢栏割惖腸lean()會(huì)清理哪些信息，如果完全略過父類clean()，很可能本該被父類clean()清理的東西，子類沒有去清理。

真正面向?qū)ο蟮恼Z(yǔ)法

前面的所有內(nèi)容都只是為了從代碼復(fù)用的角度去演示如何從普通編程方式演變成面向?qū)ο缶幊獭，F(xiàn)在，簡(jiǎn)單介紹python面向?qū)ο缶幊痰恼Z(yǔ)法，實(shí)現(xiàn)前文的animal、horse、cow和sheep，由此來和前文的推演做個(gè)比較。關(guān)于面向?qū)ο?，更多?nèi)容在后面的文章會(huì)介紹。

使用class關(guān)鍵字定義類，就像定義函數(shù)一樣。這里定義4個(gè)類，父類animal，子類cow、sheep、horse，子類繼承父類。它們分別保存到animal.py、cow.py、sheep.py和horse.py文件中。

animal.py文件：

# 定義Animal類
class Animal():
 def speak(self):
  print( "a %s goes %s!" % (self, self.sound()) )
 def sound(self):
  pass

cow.py文件：

import animal

# 定義Cow類，繼承自Animal
class Cow(animal.Animal):
 def sound(self):
  return "moooo"

sheep.py文件：

import animal

# 定義Sheep類，繼承自Animal
class Sheep(animal.Animal):
 def sound(self):
  return "baaaah"

horse.py文件：

import animal

# 定義Horse類，繼承自Animal
class Horse(animal.Animal):
 def sound(self):
  return "neigh"

在main.py文件中生成這3個(gè)子類的實(shí)例，并通過實(shí)例對(duì)象去調(diào)用定義在父類的speak()方法：

import cow,horse,sheep

# 生成這3個(gè)子類的實(shí)例對(duì)象
cowA = cow.Cow()
sheepA = sheep.Sheep()
horseA = horse.Horse()

# 通過實(shí)例對(duì)象去調(diào)用speak()方法
cowA.speak()
sheepA.speak()
horseA.speak()

輸出結(jié)果：

a <cow.Cow object at 0x03341BD0> goes moooo!
a <sheep.Sheep object at 0x03341BF0> goes baaaah!
a <horse.Horse object at 0x03341F50> goes neigh!

輸出結(jié)果和想象中不一樣，先別管結(jié)果。至少如果把<xxx>換成對(duì)應(yīng)的實(shí)例對(duì)象名稱，就和前文的效果一樣了。這個(gè)稍后再改。

先看語(yǔ)法。

使用class關(guān)鍵字聲明類，類名一般首字母大寫。如果要繼承某個(gè)類，在類名的括號(hào)中指定即可，例如class Cow(Animal)。

因?yàn)镃ow、Horse、Sheep類繼承了Animal類，所以即使這3個(gè)子類沒有定義speak()方法，也將擁有(繼承)父類Animal的speak()方法。

通過調(diào)用類，可以創(chuàng)建這個(gè)類的實(shí)例對(duì)象。例如上面cowA=cow.Cow()，表示創(chuàng)建一個(gè)Cow()的對(duì)象，這個(gè)對(duì)象在內(nèi)存中，賦值給了cowA變量。也即是說cowA引用了這個(gè)對(duì)象，是這個(gè)對(duì)象的唯一標(biāo)識(shí)符。注意，cowA是變量，因?yàn)橐脤?duì)象，所以可以稱為對(duì)象變量。

當(dāng)調(diào)用cowA.speak()時(shí)，首先查找speak()方法，因?yàn)闆]有定義在Cow類中，于是查找父類Animal，發(fā)現(xiàn)有speak()方法，于是調(diào)用父類的speak()方法。調(diào)用時(shí)，python會(huì)自動(dòng)將cowA這個(gè)對(duì)象作為speak()的第一個(gè)參數(shù)，它將傳遞給Animal類中speak()的self參數(shù)，所以此時(shí)self表示cowA這個(gè)對(duì)象，self.sound()表示cowA.sound()，由于Cow類中定義了sound()，所以直接調(diào)用Cow類的sound()，而不會(huì)調(diào)用Animal中的sound()。

和前面的推演代碼復(fù)用的過程比較一下，不難發(fā)現(xiàn)面向?qū)ο蟮恼Z(yǔ)法要輕便很多，它將很多過程自動(dòng)化了。

現(xiàn)在還有一個(gè)問題，上面的代碼輸出結(jié)果不是我們想要的。見下文。

類的屬性

為了讓speak()輸出對(duì)象名(如對(duì)象變量名cowA)，這并非一件簡(jiǎn)單的事。

在python中，變量都是保存對(duì)象的，變量和數(shù)據(jù)對(duì)象之間是相互映射的，只要引用變量就會(huì)得到它的映射目標(biāo)。如果這個(gè)對(duì)象具有__name__屬性，則直接引用該屬性即可獲取該變量的名稱，很簡(jiǎn)單。

但是很多對(duì)象并沒有__name__屬性，比如自定義的類的對(duì)象實(shí)例，這時(shí)想要獲取類的對(duì)象變量名，實(shí)非易事。有兩個(gè)內(nèi)置函數(shù)可以考慮：globals()函數(shù)和locals()函數(shù)，它們返回當(dāng)前的全局變量和本地變量的字典。遍歷它們并對(duì)字典的value和給定變量進(jìn)行比較，即可獲取想要的變量名key。

但如果跨文件了，例如Animal類在一個(gè)文件，Cow類在一個(gè)文件，創(chuàng)建對(duì)象的代碼又在另一個(gè)文件，它們的作用域都是各自獨(dú)立的，想要在Animal類的方法speak()中獲取Cow類的對(duì)象變量名cowA，python應(yīng)該是沒辦法實(shí)現(xiàn)的(perl支持，且實(shí)現(xiàn)非常簡(jiǎn)單)。

所以，只能使用另一種標(biāo)識(shí)對(duì)象的方法：為類添加屬性，例如name屬性，然后在speak()中引用對(duì)象的這個(gè)name屬性即可。

修改animal.py文件如下：

class Animal():
 def speak(self,name):
  self.name = name
  print( "a %s goes %s!" % (self.name, self.sound()) )
 def sound(self):
  pass

然后，在main.py中調(diào)用speak()的時(shí)候，傳遞name參數(shù)即可：

import cow,horse,sheep

# 生成這3個(gè)子類的實(shí)例對(duì)象
cowA = cow.Cow()
sheepA = sheep.Sheep()
horseA = horse.Horse()

# 通過實(shí)例對(duì)象去調(diào)用speak()方法
cowA.speak("cowA")
sheepA.speak("sheepA")
horseA.speak("horseA")

輸出結(jié)果：

a cowA goes moooo!
a sheepA goes baaaah!
a horseA goes neigh!

這正是期待的結(jié)果。

構(gòu)造方法__init__()

上面是在speak()方法中通過self.name = name的方式設(shè)置對(duì)象horseA的name屬性。一般來說，對(duì)于那些對(duì)象剛創(chuàng)建就需要具備的屬性，應(yīng)當(dāng)放在構(gòu)造方法中進(jìn)行設(shè)置。

構(gòu)造方法是指從類構(gòu)造對(duì)象時(shí)自動(dòng)調(diào)用的方法，是對(duì)象的初始化方法。python的構(gòu)造方法名為__init__()。以下是在構(gòu)造方法中設(shè)置name屬性的代碼：

class Animal():
 def __init__(self,name):
  self.name = name

 def speak(self):
  print( "a %s goes %s!" % (self.name, self.sound()) )

 def sound(self):
  pass

然后構(gòu)造horseA對(duì)象的時(shí)候，傳遞name參數(shù)的值即可構(gòu)造帶有name屬性的對(duì)象：

horseA = Horse("baima")
horseA.speak()

__init__()是在調(diào)用Horse()的時(shí)候自動(dòng)被調(diào)用的，由于Horse類中沒有定義構(gòu)造方法，所以將搜索繼承自父類的構(gòu)造方法__init__()，發(fā)現(xiàn)定義了，于是調(diào)用父類的構(gòu)造方法，并將對(duì)象名horseA傳遞給self參數(shù)，然后設(shè)置該對(duì)象的name屬性為"baima"。

python設(shè)置或添加對(duì)象的屬性和其它語(yǔ)言非常不同，python可以在任意地方設(shè)置對(duì)象的屬性，而不必先在構(gòu)造方法中聲明好具有哪些屬性。比如前面在speak()方法中通過self.name = name設(shè)置，此外還可以在main.py文件中添加對(duì)象的屬性。例如添加一個(gè)color屬性：

horseA = Horse("baima")
horseA.color = "white"

只要通過self.xxx或者obj_name.xxx的方式設(shè)置屬性，無論在何處設(shè)置都無所謂，都會(huì)是該對(duì)象獨(dú)有的屬性，都會(huì)被代表名稱空間的__dict__屬性收集到。

horseA.__dict__

總結(jié)

以上就是這篇文章的全部?jī)?nèi)容了，希望本文的內(nèi)容對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，如果有疑問大家可以留言交流，謝謝大家對(duì)腳本之家的支持。

最新評(píng)論