Python面向對象基礎：編碼細節和注意事項

在前面，我用了3篇文章解釋python的面向對象：

1. 面向對象：從代碼複用開始
   
2. 面向對象：設置對象屬性
   
3. 類和對象的名稱空間

本篇是第4篇，用一個完整的示例來解釋面向對象的一些細節。

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

定義Employe類

如今，假設Employe類有3個屬性：名字name、職稱job和月薪水pay。

定義這個類：

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

這裏爲__init__()的job參數提供了默認值：None，表示這個員工目前沒有職稱。對於沒有職稱的人，pay固然也應該是0。這樣建立Employe對象的時候，能夠只給參數name。

例如：

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

上面的if判斷表示這個py文件若是看成可執行程序而不是模塊，則執行if內的語句，若是是以模塊的方式導入這個文件，則if內的語句不執行。這種用法在測試模塊代碼的時候很是方便。

運行該py文件，獲得結果：

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

添加方法

每一個Employe對象的name屬性由姓、名組成，中間空格分隔，如今想取出每一個對象的名。對於普通的姓 名字符串，可使用字符串工具的split()函數來處理。

例如：

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

因而能夠在longshuai和xiaofang這兩個Employe對象上：

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

結果：

Longshuai
Xiaofang

與之相似的，若是想要爲員工按10%加薪水，能夠在每一個Employe對象上：

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

不管是截取name的名部分，仍是加薪水的操做，都是Employe共用的，每一個員工均可以這樣來操做。因此，更合理的方式是將它們定義爲類的方法，以便後續的代碼複用：

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()進行類型轉換，由於整數乘以一個小數，返回結果會是一個小數(例如15000 * 0.1 = 1500.0)。這裏咱們不想要這個小數，因此使用int()轉換成整數。

定義子類並重寫父類方法

如今定義Employe的子類Manager。

class Manager(Employe):

Manager的薪水計算方式是在原有薪水上再加一個獎金白分別，因此要重寫父類的giveRaise()方法。有兩種方式能夠重寫：

1. 徹底否認父類方法
   
2. 在父類方法的基礎上進行擴展

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

下面是第一種方式重寫：

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

這種重寫方式邏輯很簡單，可是徹底否認了父類的giveRaise()方法，完徹底全地從新定義了本身的方法。這種方式不合理，由於若是修改了Employe中的giveRaise()計算方法，Manager中的giveRaise()方法也要修改。

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

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

第二種方式是在本身的giveRaise()方法中調用父類的giveRaise()方法。這樣的的好處是在須要修改薪水計算方式時，要麼只需修改Employe中的，要麼只需修改Manager中的，不會同時修改多個。

另外注意，上面是經過硬編碼的類名Employe來調用父類方法的，雖然不適合後期維護。但好在並無任何影響。由於調用時明確指定了第一個參數爲self，而self表明的是對象自身，因此邏輯上仍然是對本對象的屬性self.pay進行修改。

Python支持另外一隻更好的調用父類方法的方式：super()。這個函數有點複雜，但對於基本的調用父類方法來講，用法無比的簡單。修改上面的Manager類：

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

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

測試下：

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

通常在重寫方法的時候，只要容許，就應該選擇在父類基礎上進行擴展重寫。若是真的須要定義徹底不一樣的方法，能夠不要重寫，而是在子類中定義新的方法。固然，若是真的有需求要重寫，且又要否認父類方法，那也沒辦法，不過這種狀況基本上都是由於在類的設計上不合理。

定製子類構造方法

對於子類Manager，每次建立對象的時候其實沒有必要去傳遞一個參數"job=mgr"的參數，由於這是這個子類天然具有的。因而，在構造Manager對象的時候，可讓它自動設置"job=mgr"。

因此，在Manager類中重寫__init__()。既然涉及到了重寫，就有兩種方式：(1)徹底否認父類方法，(2)在父類方法上擴展。不管什麼時候，總應當選第二種。

如下是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)

如今構造Manager對象的時候，只需給name和pay就能夠：

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

子類必須重寫方法

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

本文的這個示例很差解釋這一點。下面簡單用父類Animal、子類Horse、子類Sheep、子類Cow來講明，這個例子來源於我寫的面向對象相關的第一篇文章：從代碼複用開始。

如今要爲動物定義叫聲speak()方法，方法的做用是輸出"誰發出了什麼聲音"。看代碼便可理解：

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()方法調用了sound()方法，但Animal類中的sound()方法卻明確拋出異常"你必須本身實現這個方法"。

爲何呢？由於每種動物發出的叫聲不一樣，而這裏又是經過方法來返回叫聲的，不是經過屬性來表示叫聲的，因此每一個子類必須定義本身的叫聲。若是子類不定義sound()，子類對象調用self.sound()就會搜索到父類Animal的名稱空間上，而父類的sound()會拋出錯誤。

如今在子類中重寫sound()，可是Cow不重寫。

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

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

class Cow(Animal):
    pass

測試：

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

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

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

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

再考慮一下，若是父類中不定義sound()會如何？一樣會在c.speak()時拋出錯誤。雖然都會終止程序，可是這已經脫離了面向對象的代碼複用原則：對於對象公有的屬性，都應該抽取到類中，對於類所公有的屬性，都應該抽取到父類中。sound()顯然是每種動物都應該具有的屬性，要麼定義爲子類變量，要麼經過類的方法來返回。

以前也提到過，若是能夠，儘可能不要定義類變量，由於這破壞了面向對象的封裝原則，打開了"黑匣子"。因此最合理的方法，仍是每一個子類重寫父類的sound()，且父類中的sound()強制要求子類重寫。

運算符重載

若是用print()去輸出咱們自定義的類的對象，好比Employe對象，獲得的都是一個元數據信息，好比包括類型和地址。

例如：

print(longshuai)
print(xiaofang)

## 結果：
<__main__.Employe object at 0x01321690>
<__main__.Employe object at 0x01321610>

咱們能夠自定義print()如何輸出對象，只需定義類的__str__()方法便可。只要在類中自定義了這個方法，print()輸出對象的時候，就會自動調用這個__str__()取得返回值，並將返回值輸出。

例如，在輸出每一個Employe對象的時候，都輸出它的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)

如今再print()輸出對象，將獲得這個對象的信息，而不是這個對象的元數據：

print(longshuai)
print(xiaofang)

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

實際上，print()老是會調用對象的__str__()，若是類中沒有定義__str__()，就會查找父類中的__str__()。這裏Employe的父類是祖先類object，它正好有一個__str__()：

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

換句話說，當Employe中定義了__str__()，就意味着重載了父類object的__str__()方法。而這個方法正好是被print()調用的，因而將這種行爲稱之爲"運算符重載"。

可能從print()上感覺不到爲何是運算符，換一個例子就很好理解了。__add__()是決定加號+運算模式的，好比3 + 2之因此是5，是由於int類中定義了__add__()。

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

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

這使得每次作數值加法運算的時候，都會調用這個__add__()來決定如何作加法：

實際上在類中定義構造函數__init__()也是運算符重載，它在每次建立對象的時候被調用。

還有不少運算符能夠重載，加減乘除、字符串串聯、大小比較等等和運算符有關、無關的均可以被重載。在後面，會專門用一篇文章來介紹運算符重載。

序列化

對象也是一種數據結構，數據結構能夠進行序列化。經過將對象序列化，能夠實現對象的本地持久性存儲，還能夠經過網絡套接字發送給網絡對端，而後經過反序列化能夠還原獲得徹底相同的原始數據。

序列化非本文內容，此處僅是介紹一下該功能，後面我會寫幾篇專門介紹python序列化的文章。