[python] [VI coding] 第十八章 繼承 - 教學區

第十八章 繼承

繼承是物件導向程式中經常被使用的特性，當新類別具有原類別之特性，但又有一些與原類別不同之處時，可以讓新類別繼承自原類別。

可將新類別視為原類別的修改版。本章將以一副牌與一手牌的兩個類別來演練繼承的概念。

在本章中提到的紙牌都是撲克牌，「牌堆」是指一副完整的牌，或者整副牌扣掉發給玩家後剩下的那些牌而言。

18-0 類別與物件屬性

「物件屬性」或「實例屬性」是相同的概念，上一章在「動動腦」貼上了類別與物件的屬性測試範例，有幾位學員對這個主題還是有些困惑，讓我們先仔細探討一下再進行本章的課程。

這裡將使用較實際的小例子加上說明，再慢慢讓類別複雜化或製造屬性的衝突，藉以釐清概念。

class Salary():
	''' 薪水類別 '''
	income = 22000  # 底薪 22k
	def __init__(self):
		pass  # 不做任何事

# 小明的薪水
ming = Salary()
print(Salary.income)
# 22000 類別屬性
print(ming.income)
# 22000 物件屬性

底薪 22000 為類別屬性，但為什麼物件屬性也是 22000 呢？

在 Salary 的類別中，並沒有定義物件屬性 income，此時 python 會先尋找是否有同名的物件屬性，此例是沒有。接著找是否有同名的類別屬性，結果是有的。

如果沒有，則會去父類別尋找同名的類別屬性，還是沒有，那才會報錯，所以 python 有找到同名屬性。顯示出來，就會如同上述的程式碼。

但物件屬性並沒有被初始化，沒有的就不會有，下次要再顯示，python 還是會依照上述規則再去找一次：

# 底薪加一萬
Salary.income += 10000
print(Salary.income)
# 32000 類別屬性被累加了
print(ming.income)
# 32000 因為沒有物件屬性，所以又去找一次類別屬性，這時類別屬性的值是 32000

這表示物件屬性並沒有在之前被初始化成 22000，如果有的話，就不會再去找了。

那反過來要證明的，是物件屬性找到類別屬性後，是不是就變成那個類別屬性了。特別是剛剛的範例，很容易讓人誤會成它們都是同一個類別屬性，但其實不是。

ming.income = 40000
print(ming.income)
# 40000 物件屬性被初始化了
print(Salary.income)
# 32000 類別屬性還是一樣沒變

由上例可看出，物件屬性並沒有因為任何操作或 python 去尋找同名屬性而變成類別屬性，當我們改變或為物件屬性初始化時，只是針對該物件屬性而已。

另外，Salary.income 在類別之外建議寫成 ming.__class__.income，可以避免類別被更名而漏改相關敘述的狀況。在物件裡就寫成 self.__class__.income，特別是在物件裡的定義，很容易沒修改到而產生錯誤。

如此一來，在 Salary 就同時擁有兩個 income 屬性，一個是類別屬性，一個是物件屬性。接下來，累加屬性的值：

# 重新實例化小明的薪水類別
ming = Salary()
# 小明表現良好，底薪從下個月開始多給 3000
ming.income += 3000
print(ming.income)
# 25000 物件屬性
print(ming.__class__.income)
# 22000 類別屬性

沒有物件屬性時，從類別屬性找到了 22000，加上 3000 後，因為有等號，所以把值給了物件屬性，也就是初始化它。

由上例可知，ming.income 不管怎樣也不會操作或影響到類別屬性，頂多是值看起來相同，但記憶體位置仍不同。

接著來改變類別屬性的值，影響的範圍會如何？

# 小華的薪水，實例化 Salary 類別
hua = Salary()
# 累加小明薪水類別屬性
ming.__class__.income += 5000
print(ming.income)
# 25000 因為上例已經初始化物件屬性，所以改變類別屬性，並不影響物件屬性的值
print(ming.__class__.income)
# * 27000 類別屬性在剛才被累加了
print(hua.__class__.income)
# * 27000 同樣的類別擁有相同的類別屬性，改變其中一個，所有類別屬性都變了。更精確地說，類別屬性永遠只有一份
print(Salary.income)
# * 27000 類別屬性
print(hua.income)
# 27000 因為 hua 物件屬性 income 不存在，所以會去找同名的類別屬性來顯示

結果與我們預期的相同，累加類別屬性並不影響物件屬性的值，它們是分開的。

請注意，上例中，數字前打星號的都是指同一個類別屬性。改寫一下 Salary 類別，在裡面加入另一個 income 屬性：

class Salary():
	''' 薪水類別 '''
	income = 22000  # 底薪 22k 類別屬性
	def __init__(self):
		income = 30000  # 區域變數
	def showIncome(self):
		print('self.income =', self.income)  # 物件屬性不存在
		print('income =', income)  # 這個方法中並沒有 income 區域變數

# 小明的薪水
ming = Salary()
ming.showIncome()
# 執行結果
self.income = 22000  # 由前文可知，顯示的值來自於類別屬性，因為我們沒有定義物件屬性 self.income
Traceback (most recent call last):
  File "D:\test.py", line 13, in <module>
    ming.showIncome()
  File "D:\test.py", line 9, in showIncome
    print('income =', income)
NameError: name 'income' is not defined
# 名稱錯誤：income 沒有被定義

在 showIncome 方法中，的確沒有定義 income 屬性或變數，因為 income 是一般的區域變數，所以 python 不會去其他方法找。在 showIncome 方法的定義中，因為有 self 參數，就會把整個物件帶進來，而 self.__class__.income (類別屬性) 不需要傳遞，就可以在類別中自由使用。

至於 __init__ 裡的 income 在 __init__ 方法結束就消失了，除非當成參數傳遞給其他方法。self 傳遞的是整包物件，並不會傳入方法的區域變數。

最後，整理如下：

# 類別屬性
Salary.income = Self.__class__.income
# 物件屬性
self.income
# 一般區域變數
income

上面的觀念清楚後，回頭檢視上一章動動腦的第一部分，並加上註解分析：

class Test():
	a = 123  # 類別屬性
	def __init__(self):
		pass  # 沒有宣告物件屬性，沒做任何事
	def pr(self):
		print(self.a)  # 被調用時會去尋找類別屬性的值

t1 = Test()
t2 = Test()
t1.pr()
# 123 物件屬性，值是找出來的類別屬性值
t2.pr()
# 123 物件屬性，值是找出來的類別屬性值
print(Test.a)
# 123 類別屬性
t1.a = 10 # t1 初始化物件屬性的值，只針對 t1 這個物件而已
t1.pr()
# 10 因為物件屬性已經被初始化為 10 了，所以不會再往上找
t2.pr()
# 123 這裡 t2 並沒有初始化物件屬性的值，所以還是與類別屬性的值相同
print(Test.a)
# 123 我們並沒有改變過類別屬性的值，所以值不變
Test.a = 100  # 改變了類別屬性的值，會影響同一類別的所有物件中的類別屬性
t1.pr()
# 10 別忘了，t1 的物件屬性已經在之前初始化為 10 了
t2.pr()
# 100 t2 一直沒有初始化物件屬性的值，所以會去找類別屬性的值，而類別屬性的值剛才被我們改變了
print(Test.a)
# 100 類別屬性
t2.a = 1000 # t2 初始化物件屬性的值，只針對 t2 這個物件而已
t1.pr()
# 10 還是 10，因為物件屬性是不會相互影響的
t2.pr()
# 1000 剛剛已經初始化物件屬性了
print(Test.a)
# 100 類別屬性

上一章動動腦的第二部分也加上註解分析：

class Uest():  # 沒寫錯，因為剛剛用了 Test ，那就來個 Uest 吧
	def __init__(self):
		self.a = 123  # 初始化物件屬性，沒有類別屬性
	def pr(self):
		print(self.a)  # 顯示物件屬性

u1 = Uest()
u2 = Uest()
u1.pr()
# 123 物件屬性
u2.pr()
# 123 物件屬性
print(Uest.a)
# AttributeError: type object 'Uest' has no attribute 'a'
# 沒有定義類別屬性，當然就找不到
u1.a = 10  # u1 改變自己物件屬性的值
u1.pr()
# 10 物件屬性
u2.pr()
# 123 u2 物件屬性的值並沒有被改變

最後是上一章動動腦的第三部分，也加上註解分析：

class Bank():
	''' 銀行類別 '''
	#money = 1000 被註解掉了喔
	def addMoney(self, m):
		''' 加總存款並回傳 '''
		return self.money + m  # m 是這個方法的參數，也就是區域變數
	def printMoney(self):
		''' 顯示有多少存款 '''
		print(f'我有 {self.money} 元')

# Bank 類別沒有定義類別屬性，也沒有定義物件屬性
b = Bank()
c = Bank()
b.money = 123  # b 初始化物件屬性 money
x = b.addMoney(100)
print('x = ', x)
# 223 因為已經初始化物件屬性 money 為 123，那加上 100 就是 223，把這個值回傳給 x
b.printMoney()
# 123 因為在 addMoney 方法中，物件屬性 self.money 的值並沒有被改變，沒有等號，所以式子算完 return 回傳就結束了
print(Bank.money)
# AttributeError: type object 'Bank' has no attribute 'money'
# 沒有定義類別屬性，所以找不到
Bank.money += 100
# AttributeError: type object 'Bank' has no attribute 'money'
# 一樣，沒有定義類別屬性，沒有初始值，無法做累加運算
b.printMoney()
# 123 物件屬性並沒有被改變
c.printMoney()
# AttributeError: 'Bank' object has no attribute 'money'
# 沒有定義類別與物件屬性，在找不到物件屬性，往父類別也找不到類別屬性的情況下，只好報錯

最後，整理幾條規則供大家參考：

• 類別屬性會影響同一類別的所有物件中的類別屬性
• 類別屬性沒有定義就是不存在
• 沒有初始化物件屬性，又直接使用，就會搜尋同名的屬性值，從物件 -> 類別 -> 父類別的順序開始找，找不到就報錯
• 當物件屬性已經初始化，就不會再去找類別屬性了，因為上一點優先順序的關係
• 物件屬性就是物件屬性，類別屬性還是類別屬性，意思就是操作物件屬性不可能變成操作類別屬性，反之亦然

18-1 紙牌物件

一副牌有52張，包含4種花色及1到13點。每張牌上有一種花色跟一個點數。

4種花色由大到小分別為：黑桃、紅心、方塊、梅花，13點分別為：A、2、3、4、5、6、7、8、9、10、J、Q、K。依據遊戲的不同，有時 A 會大於 K 且小於 2 ，所以在比較大小時，要特別注意該遊戲本身的規則。

如果要定義紙牌類別，裡面需要兩個屬性，很明顯地分別是花色與點數，但不明顯之處是需要用哪一種型態較佳。

一個可能是使用字串，包含花色與點數 J、Q、K 等。這些文字都可以很順利地存進屬性，但在執行上遇到的問題是不方便做大小的比較。

另外一個選擇是使用整數來對花色與點數做編碼，編碼是指使用數字來替代花色與點數，下列是整數與花色的編碼對照：

• 黑桃 -> 3
• 紅心 -> 2
• 方塊 -> 1
• 梅花 -> 0

如此可以方便地比較花色的大小，剛好整數的大小就等於實際花色的大小。

整數要對應點數也很簡單，大部分的牌就按照牌本身的點數，只是要特別注意這幾張牌是例外：

• A -> 1
• J -> 11
• Q -> 12
• K -> 13

最後，紙牌的類別定義如下：

class Card:
	''' 代表撲克牌 '''
	def __init__(self, s=0, r=2):
		self.suit = s
		self.rank = r

__init__ 初始化方法使用了有預設值的參數寫法，若沒有給定預設值時，它會是「梅花 2」這張牌。

現在可以產生撲克牌了，想要什麼花色與點數，都可以帶進紙牌物件中，下一節再來處理顯示部分：

q_of_d = Card(1, 12)

18-2 類別屬性

需要使用實際玩牌的方式來顯示紙牌，我們很自然地會使用字串列表，那就給一個列表作為類別屬性：

# 在紙牌類別中
	suit_names = ['梅花', '方塊', '紅心', '黑桃']
	rank_names = [None, 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
	def __str__(self):
		return '%s %s' % (Card.suit_names[self.suit], Card.rank_names[self.rank])

像 suit_names 與 rank_names 這樣的變數，被定義在 Card 裡，而在所有方法外，那就是類別屬性，它與 Card 類別直接關聯。

而 self.suit 與 self.rank 稱為實例屬性或物件屬性，因為它們與特定的物件實例相關聯。

這兩種屬性都是使用點符號 (.) 來呼叫，以 __str__ 方法來說，self 代表 Card 物件，self.rank 就是自己這個類別的物件屬性。相對地，Card 是一個類別，Card.rank_names 就是字串列表的類別屬性。

每一個 card 物件都有自己的 self.suit 與 self.rank，但它們的 suit_names 與 rank_names 都是同一個。

Card.suit_names[self.suit] 是使用物件屬性 suit 當作類別屬性 suit_names 的索引，並且對應正確的字串來顯示。

rank_names 的第一個元素是 None，因為沒有 0 點的牌，這樣做可以保持索引對應的完整性，讓整數 2 可以對應到字串 2，才不會發生索引與實際數字少 1 的狀況。

之後也可以考慮使用字典來代替字串實作，現在來呈現一下紙牌的內容：

>>> card1 = Card(2, 11)
>>> print(card1)
紅心 J

結果沒問題，可以繼續延伸到下一節。

18-3 比較紙牌

使用內建的型別可以利用比較運算子 (<, >, ==) 等來比較大小，但如果是自己定義的型態呢？就像撲克牌。

看來得改寫這些運算子的原型方法來覆蓋原有的，像是 __lt__ 對應到小於運算子的行為等。

__lt__ 方法接受兩個參數，分別是 self 與 other，如果 self 確實小於 other 就回傳 True，否則回傳 False。

在撲克牌的世界裡，因為不同的遊戲，所以比大小的規則也不一樣。先以梅花 3 和方塊 2 為例，哪張牌比較大？

以點數而言，3 比 2 大；但以花色來說，方塊會比梅花大。所以必須先決定，花色或點數哪個比較重要。

在此為求簡單，直接決定花色永遠比點數重要，也就是先比花色，再比點數。按照這個規則，方塊 2 會大於梅花 3。

這就是為什麼我們得自己撰寫比較運算子的方法，因為比較的方式與常規不同。決定好比大小規則後，就可以開始寫 __lt__ 方法了：

# 在 Card 類別中
	def __lt__(self, other):
		# 先比較花色
		if self.suit < other.suit: return True
		if self.suit > other.suit: return False
		# 花色相同，再比較點數
		return self.rank < other.rank

可以使用數組讓整個方法更簡潔：

# 在 Card 類別中改寫 __lt__ 方法
	def __lt__(self, other):
		t1 = self.suit, self.rank
		t2 = other.suit, other.rank
		return t1 < t2

18-4 整副牌類別

現在我們有 Card 類別，接著要來產生一副牌就不難了。產生一個 Deck 類別，在初始方法用列表來存放 52 張牌。

class Deck:
	''' 代表一副牌 '''
	def __init__(self):
		self.cards = []
		for suit in range(4):
			for rank in range(1, 14):
				card = Card(suit, rank)
				self.cards.append(card)

使用巢狀迴圈來初始化 52 張牌較簡單，外層迴圈是花色 0 到 3，內層迴圈是點數 1 到 13。

每一張牌都是 card 物件實例，將每張牌都添加到列表中就完成了。

18-5 顯示整副牌

這是 Deck 類別的 __str__ 方法：

# 在 Deck 類別中
	def __str__(self):
		res = []
		for card in self.cards:
			res.append(str(card))
		return '\n'.join(res)

這個方法用很有效率的方式來累積一個大字串，建立一個字串列表，並且使用了字串方法 join 將列表轉為字串，在每張牌後加上換行符號，然後回傳。

結果像這樣：

>>> deck = Deck()
>>> print(deck)
梅花 A
梅花 2
梅花 3
...
黑桃 10
黑桃 J
黑桃 Q
黑桃 K

會有52行的輸出結果，如果沒有使用換行符號，一整行會變得太冗長。等下被 Hand 繼承後，可以利用在顯示玩家的一手牌內容。

18-6 新增、刪除與洗牌方法

為了發牌，我們需要一個 remove 方法，從整副牌移除一張牌並回傳。列表的 pop 方法剛好符合這種需求。

# 在 Deck 方法中
	def popCard(self):
		return self.cards.pop()

發牌的分解動作，先從牌堆拿走一張牌，然後給玩家。使用 pop 方法刪除列表的最後一張牌，因此我們是從整副牌的最底部發牌。

至於給玩家那張牌，對玩家來說就是新增一張牌，用列表的 append 方法來完成：

# 在 Deck 類別中
	def addCard(self, card):
		self.cards.append(card)

像這兩個方法都是使用內建方法達成任務，而沒有額外再多做什麼，有時也被稱為 veneer (木皮或單板)。

接下來，利用 random 模組中的 shuffle 函數，來完成我們的洗牌方法：

# 在 Deck 類別中
	def shuffle(self):
		random.shuffle(self.cards)

別忘了，實際使用前，要在程式的最前面 import random 模組。

18-7 繼承

假設我們現在需要一個新類別來代表一手牌。一手牌就是一個玩家手中所持有的牌。

一手牌跟一副牌的相似之處，是兩者都需要初始化，也就是拿牌，而且會有增加或移除撲克牌的動作。

但一手牌不同於一副牌，一手牌會有一些不同的操作，像是比較兩個玩家，也就是兩手牌誰獲勝，或者計算一手牌的總分。

像這樣兩個類別，有一些共同點，但其中又各有不同的情況，就很適合使用繼承。

一個新類別繼承原有的類別，新的類別稱為子類別，被繼承的原類別稱為父類別：

class Hand(Deck):
	''' 代表一個玩家的一手牌 繼承自 Deck '''

這樣的定義表示，Hand 類別繼承了 Deck 類別，Hand 類別可以使用 Deck 類別的所有方法，像是 addCard 或 popCard 等。

但以這個例子來看，Hand 繼承了 Deck 的 __init__ 方法，它初始化52張牌，這不是我們想要的。玩家的一手牌應該先給一個空列表，依據不同的遊戲，再發給正確數目的牌。

如果我們撰寫了 Hand 的 初始化方法 __init__，那麼在 Hand 中，原 Deck 的 __init__ 將被覆蓋：

# 在 Hand 類別中
	def __init__(self, label=''):
		self.cards = []
		self.label = label

當建立 Hand 類別時，python 會使用 Hand 自己的 __init__ 方法：

>>> hand = Hand('玩家一')
>>> hand.cards
[]
>>> hand.label
'玩家一'

label 只是用來區別不同的玩家，其他沒有改寫的方法都會被繼承下來：

>>> deck = Deck()
>>> card = deck.popCard()
>>> hand.addCard(card)
>>> print(hand)
黑桃 K

下一步要被封裝的程式碼就是 moveCards 方法，功能是把牌從 A 移到 B：

# 在 Deck 類別中
	def moveCards(self, hand, num):
		for i in range(num):
			hand.addCard(self.popCard())

moveCards 方法接受兩個參數，分別是 hand 與 num，hand 是一個物件，而 num 是紙牌的數量。它會修改 self 與 hand 這兩個物件，然後回傳 None。

在某些撲克牌遊戲中，玩家的牌可以互相交換(抽鬼牌)。我們可以把 moveCards 應用在 self 與 Hand 或 self 與 Deck 之間。而 self 可以是 Hand 或 Deck。

繼承是一個好用的特性，一些經常重複又沒有繼承的程式，可以使用繼承的特性來改寫得更優雅，就像 moveCard 可以取代 popCard 與 addCard。

繼承可以提高程式碼的重用率，讓我們撰寫父類別後無須擔心有狀況時還得回來修改。在真實世界的狀況或問題，有時正符合繼承的特性，讓使用繼承的概念來開發程式變得直覺。

繼承雖然好用，但必須視案件情況決定是否使用。有時繼承不利於程式碼的閱讀，特別是在方法被調用時，相關的程式碼散落在各個模組中，想找到正確的定義變得困難，本章除錯章節會詳述。

最後補充，繼承的關係還不只這些，還有多層繼承、多重繼承等，想多了解的學員可看這篇 python繼承實用教學。

18-8 類別特性

• 類別中的物件也可能參考自其他類別物件，例如之前 Rectangle 包含對 Point 的引用；本章 Deck 引用了 Card 等。
• 類別可以繼承其他類別，例如 Hand 繼承 Deck。
• 類別可能依賴其他類別，例如把另外一個類別當作方法的參數，或者利用其他類別來做運算等。

可以參考英文講義 18-8 的類別關係圖： 本章原文。

18-9 資料封裝

對於物件的規劃與開發又稱為「物件導向設計」。在定義物件時，通常會依據它們在真實或數學世界的對應關係來規劃。

但在一些情境可能比較難確定需要的物件及它們怎麼作用，此時需要一個不同的開發計劃。

就像透過封裝與一般化的過程來確認函數最終需要的介面，同樣的，也利用資料封裝來發現類別介面。

除錯

繼承會讓除錯變得困難，如前所述，當方法被調用時，很難弄清到底是哪個物件的方法被調用了，特別是類別的關係比較複雜的專案。

在 Hand 物件裡寫的函數，都會希望它在所有 Hand 物件運作良好，像是撲克牌、橋牌等。

比方在 Hand 物件呼叫了 shuffle 洗牌方法，它被定義在 Deck 類別裡，但如果 Hand 物件裡覆寫了這個方法，那麼呼叫到的版本會是覆寫的那個，這可能很便利，但也同時帶來困擾。

當有任何不確定性時，最簡單的方式就是直接在方法的開頭使用 print 來確認。

例如在 Hand 裡的 shuffle，除錯階段可以在 shuffle 的一開始加入類似 print('執行 Hand shuffle') 語句，如此便於追蹤程式的執行流程，確認是否正確。

還有個替代方案，這裡有個函數，接受兩個參數，分別是物件名稱與方法名稱(字串型態)，它會回傳這個方法是在哪個類別被定義的：

def find_defining_class(obj, meth_name):
	for ty in type(obj).mro():
		if meth_name in ty.__dict__:
			return ty

馬上來練習一下：

>>> hand = Hand()
>>> find_defining_class(hand, 'shuffle')
<class '__main__.Deck'>

可以看出 shuffle 是被定義在 Deck 類別。我們是用 mro 方法來完成這個任務，mro 正是 'method resolution order' 的英文縮寫。

動動腦

跳脫這一章講義對於撲克牌類別的規劃，如果是你，會想要怎麼規劃這些類別及它們的關係？

• 紙牌類別，就是講義原本的 Card
• 撲克牌容器類別
  1. 新增牌方法
  2. 刪除牌方法
  3. 交換牌方法
  4. ...
• 不管是玩家的牌或是牌堆，都是撲克牌容器類別的一個物件實例

不過這樣的架構就用不到繼承了。

習題

練習 1 檔名： 18-1.py

寫一小段程式來呼叫 moveCards 這個方法，模擬兩個玩家，一次把 5 張牌從 A 玩家移到 B 玩家。

練習 2 檔名： 18-2.py

在 Hand 類別中，寫一個計算玩家所有牌總分的方法。計分規則如下：

• 花色為紅心與方塊的牌才算分
• 點數 A = 50 分
• 點數 J、Q、K = 10 分
• 點數 2 到 10 的分數就跟點數一樣

練習 3 檔名： 18-3.py

讓兩個玩家從牌堆中各任意取得 5 張牌，寫一個方法來分別計算一手牌的分數，再寫一個方法，帶入兩個玩家來判斷是誰獲勝。

計分規則：

• 出現一對就拿 5 分(兩張點數一樣)
• 出現三條就拿 10 分(三張點數一樣)
• 全部相同花色就拿 12 分
• 拿到鐵支 20 分(四張點數都一樣)
• 拿到順子 30 分(點數按照順序排列，如 A 2 3 4 5，或 10 J Q K A，但 J Q K A 2 不算)

注意，如果出現四張點數一樣的要算鐵支，而不是兩個一對。

影片

第十八章 繼承