python 繼承Vs.包含

2021-09-15 14:57 更新

練習(xí)44.繼承Vs.包含

在有關(guān)英雄戰(zhàn)勝邪惡的童話中，總是有某種形式的黑暗森林。它可能是一個山洞，森林，另一個星球或者其他地方，每個人都知道英雄不應(yīng)該去。當(dāng)然，當(dāng)不就之后壞人被你找到的時候，你發(fā)現(xiàn)，英雄已經(jīng)去那個愚蠢的森林里殺壞人去了。看起來英雄進(jìn)入了一種狀態(tài)，這種狀態(tài)要求英雄必須在這個邪惡的森林中冒險。

在面向?qū)ο缶幊讨?，繼承就是那個黑暗森林。有經(jīng)驗的程序員知道要避免這種邪惡,因為他們知道,黑暗森林深處有著多重繼承這個邪惡的皇后。 她喜歡那她那龐大的牙齒吃掉軟件和程序員。但這個森林是如此強大，如此誘人，幾乎每一個程序員都必須進(jìn)入它，與邪惡的皇后戰(zhàn)斗，盡量做到全身而退，才可以稱自己是真正的程序員。你不能抗拒的繼承森林的誘惑，所以你進(jìn)去了。冒險之后，你試著遠(yuǎn)離那個邪惡的森林，當(dāng)你再次被迫進(jìn)入的時候，你會攜帶一支軍隊進(jìn)入（這段翻譯的太爛了，實在沒辦法把編程和童話聯(lián)系起來?。?/p>

這是一種有趣的方式來解說我要在這節(jié)練習(xí)教你的東西，它叫做繼承，當(dāng)你使用它的時候，一定要當(dāng)心再當(dāng)心。正在森林里和女王戰(zhàn)斗的程序員可能告訴你你必須進(jìn)去。他們這么說是因為他們需要你的幫忙，可能因為他們創(chuàng)建了太多他們已經(jīng)無法掌控的東西。但是你一定要記得：

大多數(shù)繼承的用途，可以簡化或用組合物所取代，并應(yīng)不惜一切代價避免多重繼承。

什么是繼承

繼承是用來描述一個類從它的父類那里獲得大部分甚至全部父類的功能。當(dāng)你寫下class Foo(Bar)的時候，就發(fā)生了繼承，這句代碼的意思是“創(chuàng)建一個叫做Foo的類，并繼承Bar” 。當(dāng)你執(zhí)行這句的時候，編程語言使得Foo的實例所有的行為都跟Bar的實例一樣。這么做，可以讓你在類Bar中放一些通用功能，而那些需要特殊定制的函數(shù)或功能可以放在類 Foo 中。

當(dāng)你需要做這些特殊化函數(shù)編寫的時候，父子類之間有3中交互方法：

  1. 子類的方法隱性繼承父類方法
  2. 子類重寫父類的方法
  3. 對子類的操作改變父類

我將按順序給你展示這3種交互方式，并給你看它們的代碼。

隱性繼承

首先，我將給你展示的是隱性繼承發(fā)生在你在父類中定義了方法，而在子類中沒有：

class Parent(object):

    def implicit(self):
        print "PARENT implicit()"

class Child(Parent):
    pass

dad = Parent()
son = Child()

dad.implicit()
son.implicit()

在class Child下使用pass的目的是告訴Python，在這里你想要一個空白的塊。這里創(chuàng)建了一個叫做Child的類，但是沒有在這個類中定義任何性的方法。它將從類Parent繼承獲得所有的方法。當(dāng)你執(zhí)行這段代碼的時候，你會看到：

$ python ex44a.py
PARENT implicit()
PARENT implicit()

注意一下，盡管我再代碼的13行調(diào)用了son.implicit()，而類Child并沒有一個定義叫做implicit的方法，代碼仍然正常工作了，因為它調(diào)用了Parent中定義的同名方法。這個高速你的是：如果你在基類(i.e., Parent)中定義了一個方法，那么所有的子類(i.e., Child) 都可以自動的獲得這個功能。對于你需要在很多類中有重復(fù)的方法來說，非常方便。

重寫方法

關(guān)于有些方法是隱式調(diào)用的問題原因在于有時候你想讓子類有不同的表現(xiàn)。這時你想重寫子類中的方法且有效的覆蓋父類中的方法。要做到這一點，你只需要在子類中定義一個同名的方法就行，例如

class Parent(object):

    def override(self):
        print "PARENT override()"

class Child(Parent):

    def override(self):
        print "CHILD override()"

dad = Parent()
son = Child()

dad.override()
son.override()

在這個例子中，兩個類中我都有一個叫做override的方法，所以讓我們來看看當(dāng)你運行此例時都發(fā)生了什么

$ python ex44b.py
PARENT override()
CHILD override()

你可以看到，當(dāng)?shù)?4行執(zhí)行時，它執(zhí)行了父類的override方法，因為變量dad是一個父類實例，但是當(dāng)?shù)?5行執(zhí)行時，打印的是子類的override方法，這是因為son是一個子類的實例，這個子類重寫了那個方法，定義了自己的版本。

休息以下，在繼續(xù)下面的內(nèi)容之前，嘗試練習(xí)這兩種方法。

之前或之后改變父類

第三種使用繼承的方式比較特別，你想在父類版本的方法執(zhí)行行為前后給出些提示，你首先像上個例子那樣重寫了方法，接著你使用一個Python內(nèi)建的叫做super的方法得到了父類版本的方法調(diào)用。以下這個例子就是這么做的，你可以感受一下上面的描述是什么意思。

class Parent(object):

    def altered(self):
        print "PARENT altered()"

class Child(Parent):

    def altered(self):
        print "CHILD, BEFORE PARENT altered()"
        super(Child, self).altered()
        print "CHILD, AFTER PARENT altered()"

dad = Parent()
son = Child()

dad.altered()
son.altered()

重要的地方在于9-11行，在son.altered()被調(diào)用前我做了如下操作：

  1. 因為我已經(jīng)重寫了子類的Child.altered方法，第9行的運行結(jié)果應(yīng)該和你的期待是一樣
  2. 在這個例子中，我打算使用super來得到父類的Parent.altered版本。
  3. 在第10行，我調(diào)用了super(Child, self).altered()方法, 這個方法能夠意識到繼承的發(fā)生，并給你獲得類Parent。你可以這樣讀這行代碼“調(diào)用super，參數(shù)為Child和self,然后不管它返回什么，調(diào)用方法altered ”
  4. 在這種情況下，父類的Parent.altered版本執(zhí)行，并打印出父類的信息。
  5. 最后，代碼從Parent.altered 返回， Child.altered 方法繼續(xù)打印出剩下的信息。

運行了程序之后，你應(yīng)該能看到下面的內(nèi)容：

$ python ex44c.py
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

三種組合使用

為了論證上面的三種方式，我有一個最終版本的文件，該文件給你展示了每一種繼承方式的交互：

class Parent(object):

    def override(self):
        print "PARENT override()"

    def implicit(self):
        print "PARENT implicit()"

    def altered(self):
        print "PARENT altered()"

class Child(Parent):

    def override(self):
        print "CHILD override()"

    def altered(self):
        print "CHILD, BEFORE PARENT altered()"
        super(Child, self).altered()
        print "CHILD, AFTER PARENT altered()"

dad = Parent()
son = Child()

dad.implicit()
son.implicit()

dad.override()
son.override()

dad.altered()
son.altered()

通讀每一行代碼，不管有沒有被重寫，寫一個注釋用來解釋每一行實現(xiàn)了什么，然后將代碼運行起來，確認(rèn)你的結(jié)果和你的期望是否一致：

$ python ex44d.py
PARENT implicit()
PARENT implicit()
PARENT override()
CHILD override()
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

使用super()的原因

這看起來應(yīng)該是常識，但是隨后我們即將進(jìn)入一個叫做所多重繼承的麻煩事。 多重繼承是指當(dāng)你定義一個的類的時候，從一個或多個類繼承，例如:

class SuperFun(Child, BadStuff):
    pass

上述代碼的意思是, "創(chuàng)建一個叫做SuperFun的類，它同時繼承類Child 和類 BadStuff ."

在這個例子中，只要你隱式的調(diào)用任何SuperFun的實例，Python把必須從類Child和BadStuff查詢可能的函數(shù)，但是，查找也需要一個順序。為了做到這點，Python使用"方法解析順序"(MRO)和一種叫做C3的運算法則來直接獲得。

因為MRO是復(fù)雜的，并使用了明確定義的算法，Python不能讓你來獲得正確的MRO，相反的，Python提供給你super()方法，它用來處理所有這一切你需要改變類型的行為，如同我在Child.altered所實現(xiàn)的。使用super()你不必?fù)?dān)心得到的是否是正確的方法，Python會幫你找到正確的那個。

__init__中使用super()

super()最常見的用途是在基類的__init__方法里。這通常是你需要在子類里實現(xiàn)什么事情，然后完成父類初始化的地方。以下是在類Child中這樣做的一個簡單的例子:

class Child(Parent):

    def __init__(self, stuff):
        self.stuff = stuff
        super(Child, self).__init__()

除了我在__init__中初始化父類之前定義了一些變量，這個跟上面的例子Child.altered幾乎是一樣的。

包含

繼承是有用的， 但另一種方式僅僅是用其他類和模塊就做到了同樣的事情， 而沒有使用隱性繼承。如果你看一下使用繼承的三種方式，其中的兩種方法涉及編寫新的代碼來替換或改變父類功能。這可以很容易地通過調(diào)用模塊函數(shù)復(fù)制。下面是一個例子：

class Other(object):

    def override(self):
        print "OTHER override()"

    def implicit(self):
        print "OTHER implicit()"

    def altered(self):
        print "OTHER altered()"

class Child(object):

    def __init__(self):
        self.other = Other()

    def implicit(self):
        self.other.implicit()

    def override(self):
        print "CHILD override()"

    def altered(self):
        print "CHILD, BEFORE OTHER altered()"
        self.other.altered()
        print "CHILD, AFTER OTHER altered()"

son = Child()

son.implicit()
son.override()
son.altered()

在這段代碼中，我沒有使用名字Parent，因為沒有父子的is-a關(guān)系了。這是一個has-a關(guān)系,在這個關(guān)系中Child``has-a``Other被用來保證代碼的正常工作。當(dāng)我運行代碼時，看到以下輸出： 

$ python ex44e.py
OTHER implicit()
CHILD override()
CHILD, BEFORE OTHER altered()
OTHER altered()
CHILD, AFTER OTHER altered()

你可以看到Child和Other中的大部分代碼實現(xiàn)了相同的功能。唯一的不同之處在于我必須定義一個 Child.implicit 方法去做一個動作. 然后我可以問問自己，如果我需要一個Other類，是不是只要把它放在一個叫做other.py的模塊中就可以?

什么時候用繼承，什么時候用包含

繼承與包含的問題可以歸結(jié)為試圖解決可重復(fù)使用代碼的問題。你不想在你的軟件中有重復(fù)的代碼，因為這不是高效的干凈的代碼。繼承通過創(chuàng)建一種機制，讓你在基類中有隱含的功能來解決這個問題。而包含則是通過給你的模塊和函數(shù)可以在其他類別被調(diào)用來解決這個問題。

如果這兩種方案都能解決代碼復(fù)用問題的話，哪一個更合適呢？答案是主觀的，這看起來是令人難以相信的，但是我會給你3個指導(dǎo)性原則：

  1. 不惜一切代價避免多重繼承，因為它太復(fù)雜太不可靠。如果你必須要使用它，那么一定要知道類的層次結(jié)構(gòu)，并花時間找到每一個類是從哪里來的。
  2. 將代碼封裝為模塊，這樣就可以在許多不同的地方或情況使用。
  3. 只有當(dāng)有明顯相關(guān)的可重用的代碼，且在一個共同概念下時，可以使用繼承。

不要變成規(guī)則的奴隸。關(guān)于面向?qū)ο缶幊桃涀〉氖牵哼@是一個程序員創(chuàng)建打包和共享代碼的社會習(xí)俗。因為它是一個社會習(xí)俗，但在Python的法典中，你可能會因為跟你合作的人而被迫避開這些規(guī)則。在這種情況下，了解他們是如何使用規(guī)則的，然后去適應(yīng)形勢。

附加題

這節(jié)練習(xí)中只有一個附加題，因為這其實是一個很大的練習(xí)。閱讀 http://www.python.org/dev/peps/pep-0008/ 并嘗試將它應(yīng)用到你的代碼中。你會發(fā)現(xiàn)，有些內(nèi)容跟你從這本書學(xué)到的不同，但是現(xiàn)在你應(yīng)該能夠理解他們的建議，并將其應(yīng)用到自己的代碼中。本書中剩余部分的代碼可能會也可能不會遵循這些準(zhǔn)則，這個要取決于這些準(zhǔn)則是否會使代碼更加混亂。我建議你也這樣做，因為理解比讓大家都對你深奧的知識有印象更重要。

常見問題

Q: 我如何更好的解決我以前沒有遇到的問題？

更好的解決問題的辦法只有一個，那就是盡量多的自己解決遇到的問題。通常，人們遇到一個棘手的問題，就會沖出去尋找答案。當(dāng)你必須要把事情做好的時候，這種方法很好，但是如果你有時間的話，最好還是自己想辦法解決這個問題。盡你所能的思考這個問題，嘗試一切可能的辦法，直到你解決這個問題。在此之后你找到的答案，你覺得會更加令人滿意，而且你還會得到更好的解決問題的方法。

Q: 對象不是復(fù)制的類嗎？

在某些語言里(比如 JavaScript) 是這樣的。這些被稱為原型的語言，這些語言中對象和類沒有什么不同之處。然而在Python中，類作為模板，可以生成新對象，類似于如何使用模具制造硬幣。

以上內(nèi)容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號