前言

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

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

最初代碼

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

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

三個模塊文件的內(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)建一個程序文件main.py，導(dǎo)入這三個模塊文件，分別調(diào)用這三種動物的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 動物名 goes 叫聲!。于是為了讓代碼更具共性，或者說復(fù)用性更高，可以將各模塊文件中的動物名和叫聲都變得通用化。

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

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

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

# 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)在在動物名上和參數(shù)名上已經(jīng)完全相同，需要調(diào)用它們時，只需在函數(shù)調(diào)用處為他們傳遞不同的動物名即可。例如，在main.py中：

import cow,sheep,horse

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

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

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

# 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中，仍然可以使用之前的方式對這3個speak()進(jìn)行調(diào)用：

import cow,sheep,horse

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

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

初步理解類和對象

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

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

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

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

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

當(dāng)子類繼承了父類之后，父類有的屬性，子類可以直接擁有。因為子類一般具有自己的個性，所以子類可以定義自己的屬性，甚至修改從父類那里繼承來的屬性。例如，人類中定義的eat屬性是一種非常抽象的、共性非常強的動詞行為，如果女性人類繼承人類，那么女性人類的eat()可以直接使用人類中的eat，也可以定義自己的eat(比如淑女地吃)覆蓋從人類那里繼承來的eat(沒有形容詞的吃)，女性人類還可以定義人類中沒有定義的跳舞(dance)行為，這是女性人類的特性。子類方法覆蓋父類方法，稱之為方法的重寫(override)，子類定義父類中沒有的方法，稱為方法的擴展(extend)。

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

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

繼承

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

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

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)在，這三個模塊文件都沒有了speak()，因為它們都借用它們的"父類"animal中的speak()。

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

但注意，這里不是真正的繼承，因為python不支持非class對象的繼承，所以沒法通過非面向?qū)ο笳Z法演示繼承。但至少從代碼復(fù)用的角度上來說，它和繼承的功能是類似的。

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

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

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

import cow,horse,sheep

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

def sound(): 
 pass

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

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

self是什么

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

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

那么self到底是什么東西？

在前文，為了將cow、sheep和horse模塊中speak()函數(shù)中的動物名稱變得共性，添加了一個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)用這三個函數(shù)時，分別傳遞各自的動物名作為參數(shù)：

import cow,sheep,horse

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

所以，對于cow來說，self是名為"cow"的動物，對于sheep來說，self是名為"sheep"的動物，對于horse來說，self是名為"horse"的動物。

也就是說，self是各種動物對象，cow.speak()時是cow，sheep.speak()時是sheep，horse.speak()時是horse。這里的模塊名變量和speak()的參數(shù)是一致的，這是我故意設(shè)計成這樣的，因為面向?qū)ο笳Z法中默認(rèn)的行為和這是完全一樣的，僅僅只是因為語法不同而寫法不同。

簡而言之，self是各個動物對象自身。

后來將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)用它時：

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

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

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

重寫父類方法

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

例如，新添加一個類mouse，重寫animal的speak()方法，mouse的speak()方法中會叫兩聲，而不是其它動物一樣只有一聲。假設(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ǔ)上還叫了一聲。

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

# 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")

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

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

import animal

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

def sound():
 return "jijiji"

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

再舉一個擴展父類方法的例子。在父類中定義了一個clean()方法，用于清理、回收父類的一些信息。子類中也重寫一個clean()方法，但這時應(yīng)當(dāng)確保子類的clean()中包含了調(diào)用父類的clean()方法，再定義屬于子類獨有的應(yīng)當(dāng)清理的一些信息。這就是父類方法的擴展，而不是父類方法的直接否定。因為子類并不知道父類的clean()會清理哪些信息，如果完全略過父類clean()，很可能本該被父類clean()清理的東西，子類沒有去清理。

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

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

使用class關(guān)鍵字定義類，就像定義函數(shù)一樣。這里定義4個類，父類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個子類的實例，并通過實例對象去調(diào)用定義在父類的speak()方法：

import cow,horse,sheep

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

# 通過實例對象去調(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>換成對應(yīng)的實例對象名稱，就和前文的效果一樣了。這個稍后再改。

先看語法。

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

因為Cow、Horse、Sheep類繼承了Animal類，所以即使這3個子類沒有定義speak()方法，也將擁有(繼承)父類Animal的speak()方法。

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

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

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

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

類的屬性

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

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

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

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

所以，只能使用另一種標(biāo)識對象的方法：為類添加屬性，例如name屬性，然后在speak()中引用對象的這個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()的時候，傳遞name參數(shù)即可：

import cow,horse,sheep

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

# 通過實例對象去調(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è)置對象horseA的name屬性。一般來說，對于那些對象剛創(chuàng)建就需要具備的屬性，應(yīng)當(dāng)放在構(gòu)造方法中進(jìn)行設(shè)置。

構(gòu)造方法是指從類構(gòu)造對象時自動調(diào)用的方法，是對象的初始化方法。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對象的時候，傳遞name參數(shù)的值即可構(gòu)造帶有name屬性的對象：

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

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

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

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

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

horseA.__dict__

總結(jié)

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