前言

在前面，我用了3篇文章解釋python的面向?qū)ο螅?/p>

• 面向?qū)ο螅簭拇a復(fù)用開始
• 面向?qū)ο螅涸O(shè)置對(duì)象屬性
• 類和對(duì)象的名稱空間

本篇是第4篇，用一個(gè)完整的示例來解釋面向?qū)ο蟮囊恍┘?xì)節(jié)。

例子的模型是父類Employe和子類Manager，從類的定義開始，一步步完善直到類變得完整。

定義Person類

現(xiàn)在，假設(shè)Employe類有3個(gè)屬性：名字name、職稱job和月薪水pay。

定義這個(gè)類：

class Employe():
 def __init__(self, name, job=None, pay=0):
 self.name = name
 self.job = job
 self.pay = pay

這里為__init__()的job參數(shù)提供了默認(rèn)值：None，表示這個(gè)員工目前沒有職稱。對(duì)于沒有職稱的人，pay當(dāng)然也應(yīng)該是0。這樣創(chuàng)建Employe對(duì)象的時(shí)候，可以只給參數(shù)name。

例如：

if __name__ == "__main__":
 longshuai = Employe("Ma Longshuai")
 xiaofang = Employe("Gao Xiaofang", job="accountant", pay=15000)

上面的if判斷表示這個(gè)py文件如果當(dāng)作可執(zhí)行程序而不是模塊，則執(zhí)行if內(nèi)的語句，如果是以模塊的方式導(dǎo)入這個(gè)文件，則if內(nèi)的語句不執(zhí)行。這種用法在測(cè)試模塊代碼的時(shí)候非常方便。

運(yùn)行該py文件，得到結(jié)果：

<__main__.Employe object at 0x01321690>
<__main__.Employe object at 0x01321610>

添加方法

每個(gè)Employe對(duì)象的name屬性由姓、名組成，中間空格分隔，現(xiàn)在想取出每個(gè)對(duì)象的名。對(duì)于普通的姓 名字符串，可以使用字符串工具的split()函數(shù)來處理。

例如：

>>> name = "Ma Longshuai"
>>> name.split()[-1]
'Longshuai'

于是可以在longshuai和xiaofang這兩個(gè)Employe對(duì)象上：

print(longshuai.name.split()[-1])
print(xiaofang.name.split()[-1])

結(jié)果：

Longshuai
Xiaofang

與之類似的，如果想要為員工按10%加薪水，可以在每個(gè)Employe對(duì)象上：

xiaofang.pay *= 1.1
print(xiaofang.pay)

無論是截取name的名部分，還是加薪水的操作，都是Employe共用的，每個(gè)員工都可以這樣來操作。所以，更合理的方式是將它們定義為類的方法，以便后續(xù)的代碼復(fù)用：

class Employe():
 def __init__(self, name, job=None, pay=0):
 self.name = name
 self.job = job
 self.pay = pay

 def lastName(self):
 return self.name.split()[-1]

 def giveRaise(self, percent):
 self.pay = int(self.pay * (1 + percent))

if __name__ == "__main__":
 longshuai = Employe("Ma Longshuai")
 xiaofang = Employe("Gao Xiaofang", job="accountant", pay=15000)
 
 print(longshuai.lastName())
 print(xiaofang.lastName())
 xiaofang.giveRaise(0.10)
 print(xiaofang.pay)

上面的giveRaise()方法中使用了int()進(jìn)行類型轉(zhuǎn)換，因?yàn)檎麛?shù)乘以一個(gè)小數(shù)，返回結(jié)果會(huì)是一個(gè)小數(shù)(例如15000 * 0.1 = 1500.0)。這里我們不想要這個(gè)小數(shù)，所以使用int()轉(zhuǎn)換成整數(shù)。

定義子類并重寫父類方法

現(xiàn)在定義Employe的子類Manager。

class Manager(Employe):

Manager的薪水計(jì)算方式是在原有薪水上再加一個(gè)獎(jiǎng)金白分別，所以要重寫父類的giveRaise()方法。有兩種方式可以重寫：

• 完全否定父類方法
• 在父類方法的基礎(chǔ)上進(jìn)行擴(kuò)展

雖然有了父類的方法，拷貝修改很方便，但第一種重寫方式仍然是不合理的。合理的方式是采用第二種。

下面是第一種方式重寫：

class Manager(Employe):
 def giveRaise(self, percent, bonus=0.10):
  self.pay = int(self.pay * (1 + percent + bonus)

這種重寫方式邏輯很簡(jiǎn)單，但是完全否定了父類的giveRaise()方法，完完全全地重新定義了自己的方法。這種方式不合理，因?yàn)槿绻薷牧薊mploye中的giveRaise()計(jì)算方法，Manager中的giveRaise()方法也要修改。

下面是第二種在父類方法基礎(chǔ)上擴(kuò)展，這是合理的重寫方式。

class Manager(Employe):
 def giveRaise(self, percent, bonus=0.10):
  Employe.giveRaise(self, percent + bonus)

第二種方式是在自己的giveRaise()方法中調(diào)用父類的giveRaise()方法。這樣的的好處是在需要修改薪水計(jì)算方式時(shí)，要么只需修改Employe中的，要么只需修改Manager中的，不會(huì)同時(shí)修改多個(gè)。

另外注意，上面是通過硬編碼的類名Employe來調(diào)用父類方法的，python中沒有其它方法，只能通過這種硬編碼的方式。但好在并沒有任何影響。因?yàn)檎{(diào)用時(shí)明確指定了第一個(gè)參數(shù)為self，而self代表的是對(duì)象自身，所以邏輯上仍然是對(duì)本對(duì)象的屬性self.pay進(jìn)行修改。

測(cè)試下：

if __name__ == "__main__":
 wugui = Manager("Wu Xiaogui", "mgr", 15000)
 wugui.giveRaise(0.1, 0.1)
 print(wugui.pay)

一般在重寫方法的時(shí)候，只要允許，就應(yīng)該選擇在父類基礎(chǔ)上進(jìn)行擴(kuò)展重寫。如果真的需要定義完全不同的方法，可以不要重寫，而是在子類中定義新的方法。當(dāng)然，如果真的有需求要重寫，且又要否定父類方法，那也沒辦法，不過這種情況基本上都是因?yàn)樵陬惖脑O(shè)計(jì)上不合理。

定制子類構(gòu)造方法

對(duì)于子類Manager，每次創(chuàng)建對(duì)象的時(shí)候其實(shí)沒有必要去傳遞一個(gè)參數(shù)"job=mgr"的參數(shù)，因?yàn)檫@是這個(gè)子類自然具備的。于是，在構(gòu)造Manager對(duì)象的時(shí)候，可以讓它自動(dòng)設(shè)置"job=mgr"。

所以，在Manager類中重寫__init__()。既然涉及到了重寫，就有兩種方式：(1)完全否定父類方法，(2)在父類方法上擴(kuò)展。無論何時(shí)，總應(yīng)當(dāng)選第二種。

以下是Manager類的定義：

class Manager(Employe):
 def __init__(self, name, pay):
  Employe.__init__(self, name, "mgr", pay)

 def giveRaise(self, percent, bonus=0.10):
  Employe.giveRaise(self, percent + bonus)

現(xiàn)在構(gòu)造Manager對(duì)象的時(shí)候，只需給name和pay就可以：

if __name__ == "__main__":
 wugui = Manager("Wu Xiaogui", 15000)
 wugui.giveRaise(0.1, 0.1)
 print(wugui.pay)

子類必須重寫方法

有些父類中的方法可能會(huì)要求子類必須重寫。

本文的這個(gè)示例不好解釋這一點(diǎn)。下面簡(jiǎn)單用父類Animal、子類Horse、子類Sheep、子類Cow來說明，這個(gè)例子來源于我寫的面向?qū)ο笙嚓P(guān)的第一篇文章：從代碼復(fù)用開始。

現(xiàn)在要為動(dòng)物定義叫聲speak()方法，方法的作用是輸出"誰發(fā)出了什么聲音"?？创a即可理解：

class Animal:
 def __init__(self, name):
  self.name = name
 def speak(self):
  print(self.name + " speak " + self.sound())
 def sound(self):
  raise NotImplementedError("you must override this method")

在這段代碼中，speak()方法調(diào)用了sound()方法，但Animal類中的sound()方法卻明確拋出異常"你必須自己實(shí)現(xiàn)這個(gè)方法"。

為什么呢？因?yàn)槊糠N動(dòng)物發(fā)出的叫聲不同，而這里又是通過方法來返回叫聲的，不是通過屬性來表示叫聲的，所以每個(gè)子類必須定義自己的叫聲。如果子類不定義sound()，子類對(duì)象調(diào)用self.sound()就會(huì)搜索到父類Animal的名稱空間上，而父類的sound()會(huì)拋出錯(cuò)誤。

現(xiàn)在在子類中重寫sound()，但是Cow不重寫。

class Horse(Animal):
 def sound(self):
  return "neigh"

class Sheep(Animal):
 def sound(self):
  return "baaaah"

class Cow(Animal):
 pass

測(cè)試：

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

s = Sheep("sheepA")
s.speak()

c = Cow("cowA")
c.speak()

結(jié)果正如預(yù)期，h.speak()和s.speak()都正常輸出，但c.speak()會(huì)拋出"you must override this method"的異常。

再考慮一下，如果父類中不定義sound()會(huì)如何？同樣會(huì)在c.speak()時(shí)拋出錯(cuò)誤。雖然都會(huì)終止程序，但是這已經(jīng)脫離了面向?qū)ο蟮拇a復(fù)用原則：對(duì)于對(duì)象公有的屬性，都應(yīng)該抽取到類中，對(duì)于類所公有的屬性，都應(yīng)該抽取到父類中。sound()顯然是每種動(dòng)物都應(yīng)該具備的屬性，要么定義為子類變量，要么通過類方法來返回。

之前也提到過，如果可以，盡量不要定義類變量，因?yàn)檫@破壞了面向?qū)ο蟮姆庋b原則，打開了"黑匣子"。所以最合理的方法，還是每個(gè)子類重寫父類的sound()，且父類中的sound()強(qiáng)制要求子類重寫。

運(yùn)算符重載

如果用print()去輸出我們自定義的類的對(duì)象，比如Employe對(duì)象，得到的都是一個(gè)元數(shù)據(jù)信息，比如包括類型和地址。

例如：

print(longshuai)
print(xiaofang)

## 結(jié)果：
<__main__.Employe object at 0x01321690>
<__main__.Employe object at 0x01321610>

我們可以自定義print()如何輸出對(duì)象，只需定義類的__str__()方法即可。只要在類中自定義了這個(gè)方法，print()輸出對(duì)象的時(shí)候，就會(huì)自動(dòng)調(diào)用這個(gè)__str__()取得返回值，并將返回值輸出。

例如，在輸出每個(gè)Employe對(duì)象的時(shí)候，都輸出它的name、job、pay，并以一種自定義的格式輸出。

class Employe():
 def __init__(self, name, job=None, pay=0):
  self.name = name
  self.job = job
  self.pay = pay

 def lastName(self):
  return self.name.split()[-1]

 def giveRaise(self, percent):
  self.pay = int(self.pay * (1 + percent))

 ## 重載__str__()方法
 def __str__(self):
  return "[Employe: %s, %s, %s]" % (self.name, self.job, self.pay)

現(xiàn)在再print()輸出對(duì)象，將得到這個(gè)對(duì)象的信息，而不是這個(gè)對(duì)象的元數(shù)據(jù)：

print(longshuai)
print(xiaofang)

## 結(jié)果：
[Employe: Ma Longshuai, None, 0]
[Employe: Gao Xiaofang, accountant, 15000]

實(shí)際上，print()總是會(huì)調(diào)用對(duì)象的__str__()，如果類中沒有定義__str__()，就會(huì)查找父類中的__str__()。這里Employe的父類是祖先類object，它正好有一個(gè)__str__()：

>>> object.__dict__["__str__"]
<slot wrapper '__str__' of 'object' objects>

換句話說，當(dāng)Employe中定義了__str__()，就意味著重載了父類object的__str__()方法。而這個(gè)方法正好是被print()調(diào)用的，于是將這種行為稱之為"運(yùn)算符重載"。

可能從print()上感受不到為什么是運(yùn)算符，換一個(gè)例子就很好理解了。__add__()是決定加號(hào)+運(yùn)算模式的，比如3 + 2之所以是5，是因?yàn)閕nt類中定義了__add__()。

>>> a=3
>>> type(a)
<class 'int'>

>>> int.__dict__["__add__"]
<slot wrapper '__add__' of 'int' objects>

這使得每次做數(shù)值加法運(yùn)算的時(shí)候，都會(huì)調(diào)用這個(gè)__add__()來決定如何做加法：

實(shí)際上在類中定義構(gòu)造函數(shù)__init__()也是運(yùn)算符重載，它在每次創(chuàng)建對(duì)象的時(shí)候被調(diào)用。

還有很多運(yùn)算符可以重載，加減乘除、字符串串聯(lián)、大小比較等等和運(yùn)算符有關(guān)、無關(guān)的都可以被重載。在后面，會(huì)專門用一篇文章來介紹運(yùn)算符重載。

序列化

對(duì)象也是一種數(shù)據(jù)結(jié)構(gòu)，數(shù)據(jù)結(jié)構(gòu)可以進(jìn)行序列化。通過將對(duì)象序列化，可以實(shí)現(xiàn)對(duì)象的本地持久性存儲(chǔ)，還可以通過網(wǎng)絡(luò)套接字發(fā)送給網(wǎng)絡(luò)對(duì)端，然后通過反序列化可以還原得到完全相同的原始數(shù)據(jù)。

序列化非本文內(nèi)容，此處僅是介紹一下該功能，后面我會(huì)寫幾篇專門介紹python序列化的文章。

總結(jié)

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

最新評(píng)論