0. 請寫下這一節課你學習到的內容：格式不限，回憶並複述是加強記憶的好方式！

上節課的課後習題我們試圖模擬一個場景，裡邊有一隻烏龜和十條魚，烏龜通過吃魚來補充體力，當烏龜體力消耗殆盡或者魚吃光時遊戲結束。

現在我們想擴充套件遊戲，給魚類進行細分，有金魚（Goldfish），鯉魚（Carp），三文魚（Salmon）和鯊魚（Shark）。那麼我們就在思考一個問題：能不能不要每次都重頭到尾重新定義一個新的魚類呢？因為我們知道大部分魚的屬性和方法是相似的。如果說有一種機制可以讓這些相似的東西得以自動傳遞，我們不用每次都自己動手寫，那就方便快捷的多了。這種機制就是我們今天要講解的繼承。

語法：class 類名（父類名）：

被繼承類被稱為基類、父類或超類，繼承者被稱為子類，一個子類可以繼承它的父類的任何屬性和方法。舉例說明：

>>> class Parent:
	def hello(self):
		print("正在呼叫父類的方法")

		
>>> class Child(Parent):
	pass

>>> p = Parent()
>>> p.hello()
正在呼叫父類的方法
>>> c = Child()
>>> c.hello()
正在呼叫父類的方法

需要注意的是：如果子類中定義與父類同名的方法或屬性，則會自動覆蓋父類對應的方法和屬性。

>>> class Parent:
	def hello(self):
		print("正在呼叫父類的方法")

	
>>> class Child(Parent):
	def hello(self):
		print("正在呼叫子類的方法")

		
>>> c = Child()
>>> c.hello()
正在呼叫子類的方法
>>> p = Parent()
>>> p.hello()
正在呼叫父類的方法

但是，這裡覆蓋的是子類例項化物件裡面的方法而已，對父類的方法沒有影響。

現在大家一起動手寫一下剛才提到的魚類擴充套件的例子。

這是一個有錯誤的程式程式碼：

import random as r
class Fish:
        def __init__(self):
                self.x = r.randint(0, 10)
                self.y = r.randint(0, 10)
        def move(self):
                self.x -= 1
                print("我的位置是：", self.x, self.y)
class Goldfish(Fish):
        pass
class Shark(Fish):
        def __init__(self):
                self.hungry = True
        def eat(self):
                if self.hungry:
                        print("吃貨的夢想就是天天有吃的^_^")
                        self.hungry = False
                else:
                        print("太撐了，吃不下了")

但是上面的程式是存在錯誤的。如下：

>>> fish = Fish()
>>> fish.move()
我的位置是： 2 9
>>> goldfish = Goldfish()
>>> goldfish.move()
我的位置是： -1 7
>>> shark = Shark()
>>> shark.eat()
吃貨的夢想就是天天有吃的^_^
>>> shark.move()
Traceback (most recent call last):
  File "<pyshell#55>", line 1, in <module>
    shark.move()
  File "C:/Users/XiangyangDai/Desktop/上課程式碼/38-1.py", line 7, in move
    self.x -= 1
AttributeError: 'Shark' object has no attribute 'x'

我們在呼叫shark.move()方法的時候會報錯，這是為什麼呢？錯誤資訊告訴我們，Shark 物件沒有 x 的屬性，Goldfish 和 Shark 都是繼承Fish，Fish是有x的屬性的，但是Shark重寫了 __init__(self)方法，子類重寫了父類的方法，就會把父類的方法給覆蓋。要解決這個問題的話，我們應該在Shark 的類裡面重寫 __init__(self)方法的時候先呼叫父類的__init__(self)，實現這樣子的繼承總共有兩種技術。

• 呼叫未繫結的父類方法（該方法不重要）

import random as r
class Fish:
        def __init__(self):
                self.x = r.randint(0, 10)
                self.y = r.randint(0, 10)
        def move(self):
                self.x -= 1
                print("我的位置是：", self.x, self.y)
class Goldfish(Fish):
        pass
class Shark(Fish):
        def __init__(self):
                #呼叫未繫結的父類方法
                Fish.__init__(self)
                self.hungry = True
        def eat(self):
                if self.hungry:
                        print("吃貨的夢想就是天天有吃的^_^")
                        self.hungry = False
                else:
                        print("太撐了，吃不下了")

>>> shark = Shark()
>>> shark.move()
我的位置是： 6 0

這樣就不會報錯了，需要注意的是， Fish.__init__(self) 中的 self 是呼叫它的父類的方法，但是這個 self 是子類的例項物件。

就相當於：Fish.__init__(shark)。實際上，在上面出錯的程式程式碼執行之後，我們輸入下面的語句可是可以的：這裡就相當於重新進行了一次初始化。

>>> shark = Shark()
>>> Fish.__init__(shark)
>>> shark.move()
我的位置是： 6 1

• 使用 super 函式（完美方法）

使用super 函式能夠幫我們自動找到父類的方法，而且還會為我們傳入 self 引數，super 函式可以完美的替換上述的方法。

import random as r
class Fish:
        def __init__(self):
                self.x = r.randint(0, 10)
                self.y = r.randint(0, 10)
        def move(self):
                self.x -= 1
                print("我的位置是：", self.x, self.y)
class Goldfish(Fish):
        pass
class Shark(Fish):
        def __init__(self):
                #使用super函式
                super().__init__()
                self.hungry = True
        def eat(self):
                if self.hungry:
                        print("吃貨的夢想就是天天有吃的^_^")
                        self.hungry = False
                else:
                        print("太撐了，吃不下了")

>>> shark = Shark()
>>> shark.move()
我的位置是： 6 2

super().__init__()，super 函式的超級之處就在於你不用給定任何父類的名字，如果繼承有多重繼承或者父類的名字太過複雜的時候，也不用給出父類的名字，就可以自動幫你一層一層的找出它所有父類裡面對應的方法，由於你不需要給出父類的名字，也就意味著如果你要改變類的繼承關係，你只需要修改 class Shark(Fish): 裡面的父類的名字即可。

多重繼承：就是同時繼承多個父類的屬性和方法。

語法：class 類名（父類1名，父類2名........）：

>>> class Base1:
	def foo1(self):
		print("我是foo1，我為Base1代言...")

		
>>> class Base2:
	def foo2(self):
		print("我是foo2，我為Base2代言...")

		
>>> class C(Base1, Base2):
	pass

>>> c = C()
>>> c.foo1()
我是foo1，我為Base1代言...
>>> c.foo2()
我是foo2，我為Base2代言...

多重繼承可以同時繼承多個父類的屬性和方法，但是多重繼承很容易導致程式碼混亂，所以當你不確定你真的必須要使用多重繼承的時候，請儘量避免使用。

測試題

0. 繼承機制給程式猿帶來最明顯的好處是？

答：可以偷懶，據說這是每一個優秀程式猿的夢想！

如果一個類 A 繼承自另一個類 B，就把這個 A 稱為 B 的子類，把 B 稱為 A 的父類、基類或超類。繼承可以使得子類具有父類的各種屬性和方法，而不需要再次編寫相同的程式碼（偷懶）。

在子類繼承父類的同時，可以重新定義某些屬性，並重寫某些方法，即覆蓋父類的原有屬性和方法，使其獲得與父類不同的功能。另外，為子類追加新的屬性和方法也是常見的做法。

1. 如果按以下方式重寫魔法方法 __init__，結果會怎樣？

class MyClass:
    def __init__(self):
        return "I love FishC.com!"

答：會報錯，因為 __init__ 特殊方法不應當返回除了 None 以外的任何物件。

>>> myClass = MyClass()
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    myClass = MyClass()
TypeError: __init__() should return None, not 'str'

2. 當子類定義了與相同名字的屬性或方法時，Python 是否會自動刪除父類的相關屬性或方法？

答：不會刪除！Python 的做法跟其他大部分面向物件程式語言一樣，都是將父類屬性或方法覆蓋，子類物件呼叫的時候會呼叫到覆蓋後的新屬性或方法，但父類的仍然還在，只是子類物件“看不到”。

3. 假設已經有鳥類的定義，現在我要定義企鵝類繼承於鳥類，但我們都知道企鵝是不會飛的，我們應該如何遮蔽父類（鳥類）中飛的方法？

答：覆蓋父類方法，例如將函式體內容寫 pass，這樣呼叫 fly 方法就沒有任何反應了。

class Bird:
        def fly(self):
                print("Fly away!")

class Penguin(Bird):
        def fly(self):
                pass

>>> bird = Bird()
>>> penguin = Penguin()
>>> bird.fly()
Fly away!
>>> penguin.fly()

4. super 函式有什麼“超級”的地方？

答：super 函式超級之處在於你不需要明確給出任何基類的名字，它會自動幫您找出所有基類以及對應的方法。由於你不用給出基類的名字，這就意味著你如果需要改變了類繼承關係，你只要改變 class 語句裡的父類即可，而不必在大量程式碼中去修改所有被繼承的方法。

5. 多重繼承使用不當會導致重複呼叫（也叫鑽石繼承、菱形繼承）的問題，請分析以下程式碼在實際程式設計中有可能導致什麼問題？

class A():
    def __init__(self):
        print("進入A…")
        print("離開A…")

class B(A):
    def __init__(self):
        print("進入B…")
        A.__init__(self)
        print("離開B…")
        
class C(A):
    def __init__(self):
        print("進入C…")
        A.__init__(self)
        print("離開C…")

class D(B, C):
    def __init__(self):
        print("進入D…")
        B.__init__(self)
        C.__init__(self)
        print("離開D…")

答：多重繼承容易導致重複呼叫問題，下邊例項化 D 類後我們發現 A 被前後進入了兩次（有童鞋說兩次就兩次憋，我女朋友還不止呢……）。
這有什麼危害？我舉個例子，假設 A 的初始化方法裡有一個計數器，那這樣 D 一例項化，A 的計數器就跑兩次（如果遭遇多個鑽石結構重疊還要更多），很明顯是不符合程式設計的初衷的（程式應該可控，而不能受到繼承關係影響）。

>>> d = D()
進入D…
進入B…
進入A…
離開A…
離開B…
進入C…
進入A…
離開A…
離開C…
離開D…

為了讓大家都明白，這裡只是舉例最簡單的鑽石繼承問題，在實際程式設計中，如果不注意多重繼承的使用，會導致比這個複雜N倍的現象，除錯起來不是一般的痛苦……所以一定要儘量避免使用多重繼承。

6. 如何解決上一題中出現的問題？

答：super 函式再次大顯神威。

class A():
    def __init__(self):
        print("進入A…")
        print("離開A…")

class B(A):
    def __init__(self):
        print("進入B…")
        super().__init__()
        print("離開B…")
        
class C(A):
    def __init__(self):
        print("進入C…")
        super().__init__()
        print("離開C…")

class D(B, C):
    def __init__(self):
        print("進入D…")
        super().__init__()
        print("離開D…")

>>> d = D()
進入D…
進入B…
進入C…
進入A…
離開A…
離開C…
離開B…
離開D…

動動手

0. 定義一個點（Point）類和直線（Line）類，使用 getLen 方法可以獲得直線的長度。

提示：

• 設點 A(X1,Y1)、點 B(X2,Y2)，則兩點構成的直線長度 |AB| = √((x1-x2)2+(y1-y2)2)
• Python 中計算開根號可使用 math 模組中的 sqrt 函式
• 直線需有兩點構成，因此初始化時需有兩個點（Point）物件作為引數

import math

class Point():
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def getX(self):
        return self.x

    def getY(self):
        return self.y

class Line():
    def __init__(self, p1, p2):
        self.x = p1.getX() - p2.getX()
        self.y = p1.getY() - p2.getY()
        self.len = math.sqrt(self.x*self.x + self.y*self.y)

    def getLen(self):
        return self.len

>>> p1 = Point(1, 1)
>>> p2 = Point(4, 5)
>>> line = Line(p1, p2)
>>> line.getLen()
5.0

1. 展示一個你的作品：你已經掌握了 Python 大部分的基礎知識，要開始學會自食其力了！

請花一個星期做一個你能做出來的最好的作品（可以是遊戲、應用軟體、指令碼），使用上你學過的任何東西（類，函式，字典，列表……）來改進你的程式。"

答：這一次，我不打算提醒你要具體做點什麼和怎麼做，你需要自己來想創意。試著下手吧，程式設計就是解決問題的過程，這就意味著你要嘗試各種可能性，進行實驗，經歷失敗，然後丟掉你做出來的東西重頭開始！

當你被某個問題卡住的時候，你可以到論壇尋求幫助，把你的程式碼貼出來給其他魚油看，爭取得到別人的建議並持續修改你的程式碼，直到它讓你滿意為止！