วิธีคิดแบบนักวิทยาการคอมพิวเตอร์/Inheritance

บทที่ 16 Inheritance.
16.1 Inheritance.
ลักษณะของปัญหาส่วนใหญ่บ่อยครั้งถูกเชื่อมโยงกับ object-oriented programming คือ inheritance ความสามารถในการกำหนด class ใหม่ที่ซึ่งถูกแก้ไขเวอร์ชันของ class ที่มีอยู่
 ข้อได้เปรียบที่สำคัญของลักษณะนี้นี้คุณสามารถเพิ่ม method ใหม่ไปใน class โดยปราศจากการแก้ไข class เดิมที่มีอยู่ ซึ่งมันเรียกว่า inheritance เนื่องจาก class ใหม่สืบทอด methods ทั้งหมดมาจาก class ที่มีอยู่ การขยายคำเปรียบเทียบนี้ class ที่มีอยู่บางครั้งถูกเรียกว่า parent class และ class ใหม่อาจถูกเรียกว่า child class หรือบางครั้งเรียกว่า sub class
 Inheritance เป็นลักษณะเฉพาะที่มีประสิทธิภาพ บางโปรแกรมมีความซับซ้อนมากโดยไม่มี inheritance เราสามารถเขียนให้สั้น รัดกุม และง่ายด้วยมัน (inheritance) เช่นเดียวกัน inheritance สามารถทำให้สะดวกขึ้นในการนำโค้ดไปใช้ใหม่ เนื่องจากคุณสามารถปรับแต่พฤติกรรมการกระทำของ parent classes โดยไม่มีการแก้ไข classes เหล่านั้น ในบางกรณี โครงสร้างของ inheritance สะท้อนให้เห็นปัญหาของโครงสร้างปกติ ซึ่งทำให้โปรแกรมง่ายต่อการเข้าใจ
 ในทางตรงกันข้าม inheritance สามารถทำให้โปรแกรมยากต่อการอ่าน เมื่อ method ถูกเรียก บางครั้งไม่ชัดเจนที่ซึ่งจะหาคำจำกัดความของมัน โค้ดที่เกี่ยวเนื่องกันอาจกระจัดกระจายในระหว่างหลายๆ modules เช่นเดียวกัน หลายสิ่งเหล่านี้สามารถจัดการด้วยการใช้ inheritance สามารถจัดการได้เป็นอย่างดี ถ้าโครงสร้างปกติของปัญหาไม่ให้ยืมตัวมันเองเพื่อ inheritance รูปแบบของการเขียนโปรแกรมนี้จะทำให้เสียหายมากว่าทำให้ดี
 ในบทนี้เราจะพิสูจน์การใช้ของ inheritance เป็นส่วนของโปรแกรมซึ่งเล่น card game Old Maid หนึ่งในเป้าหมายของเราคือ เขียนโค้ดทีสามารถนำไปใช้ใหม่กับ card game อื่นๆ
16.2 A hand of cards.
เกือบจะทุกๆ card game เราต้องการแสดงให้เห็น hand of cards แน่นอน hand คล้ายกับ deck ทั้งสองอย่างสร้างขึ้นจากชุดของไพ่ และทั้งสองต้องการการกระทำ เช่น การเพิ่มและการนำไพ่ออก เช่นเดียวกัน เราต้องการความสามารถในการสับไพ่ของทั้ง deck และ hand
 Hand แตกต่างจาก deck ด้วยเช่นกันขึ้นอยู่กับเกมที่จะเล่น เราต้องการแสดงการกระทำบางอย่างบน hand ที่ทำให้ไม่รู้สึกเป็น deck ตัวอย่างใน poker เราอาจจัดกลุ่ม hand (straight, flush, etc.)
 หรือเปรียบเทียบมันกับอีก hand หนึ่ง ใน bridge เราอาจต้องการคำนวณแต้มจาก hand เพื่อทำการประมูล
 สถานการณ์นี้แนะนำให้ใช้ inheritance ถ้า hand เป็น subclass ของ deck มันจะมี methods ทั้งหมดของ deck และสามารถเพิ่ม method ใหม่เข้าไปได้
 ใน class definition ชื่อของ parent class ปรากฏอยู่ในวงเล็บ
 class Hand(Deck):
 pass
 statement นี้บ่งบอกว่า class hand สืบทอดจาก class deck ที่มีอยู่
 hand สร้าง attributes เริ่มต้นสำหรับ hand ซึ่งคือ name และ card โดย string name ระบุถึง hand ซึ่งเป็นไปได้มากด้วยชื่อของผู้เล่นที่ถือมันไว้ name เป็น optional parameter ด้วย string ที่ว่างเปล่าเป็นค่าเริ่มต้น cards เป็น list ของไพ่ใน hand เริ่มต้นด้วย list ที่ว่างเปล่า
 class Hand(Deck):
 def __init__(self, name=""):
 self.cards = []
 self.name = name
 ทุกๆ card game มันจำเป็นที่จะต้องเพิ่มและเอาไพ่ออกจาก deck การเอาไพ่ออกได้ถูกเอาใจใส่เรียบร้อยแล้ว ตั้งแต่ hand สืบทอด removeCard จาก deck แต่เราต้องเขียน addCard
 class Hand(Deck):
 def addCard(self,card) :
 self.cards.append(card)
 อีกครั้ง การละไว้บ่งบอกว่าเราต้องละเลย method อื่นๆ list เชื่อมต่อ method เพิ่มไพ่ใหม่ไปยังท้ายสุดของ list ของไพ่
16.3 Dealing cards.
ตอนนี้เรามี class hand เราต้องการแจกไพ่จาก deck เข้าไปยัง hands มันจะไม่ชัดเจนในทันทีไม่ว่า method นี้จะเข้าไปอยู่ใน class hand หรือไม่ ใน class deck ตั้งแต่มันทำงานบน deck เดียวและหลายๆ hands มันเป็นธรรมดาที่วางมันลงใน deck 
 การแจกไพ่ควรยุติธรรม ต่างเกมต่างมีความต้องการที่แตกต่างกัน เราอาจต้องการแจกไพ่ออกจาก deck ทั้งหมดในครั้งเดียวหรือเพิ่มไพ่ในแต่ละ hand
 Deal มีพารามิเตอร์ 2 ตัว เป็น list ของ hands และจำนวนไพ่ทั้งหมดที่แจก หากใน deck มีไพ่ไม่เพียงพอ method deal จะทำการหยุด
 class Deck :
 def deal(self, hands, nCards=999):
 nHands = len(hands)
 for i in range(nCards):
 if self.isEmpty: break # break if out of cards
 card = self.popCard # take the top card
 hand = hands[i % nHands] # whose turn is next?
 hand.addCard(card) # add the card to the hand
 พารามิเตอร์ตัวที่สอง nCards เป็น optional ค่าเริ่มต้นเป็น large number ที่มีประสิทธิภาพ หมายถึงไพ่ทั้งหมดใน deck จะถูกแจกจนหมด
 ตัวแปร loop i เริ่มจาก 0 ถึง nCards -1 แต่ละครั้งที่ผ่านเข้าไปใน loop ไพ่จะถูกเอาออกจาก deck โดยใช้ list method pop ซึ่งจะเอาออกและคืนรายการสุดท้ายใน list 
 Modulus operator (%) ยอมให้เราแจกไพ่ 1 ใบต่อครั้งของแต่ละ hand เมื่อ i เท่ากับจำนวน hands ใน list expression i% nHands กลับไปยังจุดเริ่มต้นของ list (index 0)
16.4 Printing a Hand.
การ print หัวข้อของ hand เราสามารถได้เปรียบของ printDeck และ __str__ method สืบทอดจาก deck ตัวอย่างเช่น
 class Deck :
 »> deck = Deck
 »> deck.shuffle
 »> hand = Hand("frank")
 »> deck.deal([hand], 5)
 »> print hand
 Hand frank contains
 2 of Spades
 3 of Spades
 4 of Spades
 Ace of Hearts
 9 of Clubs
 มันไม่ใช่ hand ที่ใหญ่ แต่มันเป็นการทำ straight flush
 ถึงแม้มันสะดวกที่จะสืบทอด existing methods มีข้อมูลที่มากขึ้นใน Hand object เราอาจต้องการรวมเมื่อเรา print ออกมา ทำโดยคุณสามารถให้ __str__ method ใน Hand class ผ่านข้ามหนึ่งใน Deck class
 class Hand(Deck)
 def __str__(self):
 s = "Hand " + self.name
 if self.isEmpty:
 return s + " is empty\n"
 else:
 return s + " contains\n" + Deck.__str__(self)
 ในขั้นต้น s คือ string ที่แสดงถึง hand ถ้า hand ว่างเปล่า โปรแกรมจะให้คำว่า empty และ return ค่าผลลัพธ์ออกมา
 ไม่เช่นนั้น โปรแกรมจะผนวกการบรรจุคำ และ string เป็นตัวแทนของ deck คำนวณโดยการสร้าง __str__ method ใน Deck class บน self
 มันอาจดูแปลกที่ส่ง self ซึ่งอ้างถึง Hand ปัจจุบัน จนกระทั่งคุณจำได้ว่า Hand คือ ชนิดของ Deck ดังนั้น Hand objects จึงสามารถทำทุกสิ่งที่ Deck objects สามารถทำได้ ดังนั้น มันถูกต้องที่จะส่ง Hand ไปยัง Deck method
 โดยทั่วไป มันจะถูกต้องเสมอที่ใช้ instance ของ subclass ในตำแหน่งของ instance ของ parent class
16.5 The CardGame class.
CardGame class ดูแลงานพื้นฐานทั่วไปของเกมทั้งหมด เช่น การสร้าง deck และ การสับไพ่
 class CardGame:
 def __init__(self):
 self.deck = Deck
 self.deck.shuffle
 นี้คือ case แรกที่เราได้เห็น initialization method กระทำการคำนวณที่สำคัญหลัง initializing attributes 
 การ implement เกมโดยเฉพาะ เราสามารถสืบทอดจาก CardGame และเพิ่มลักษณะต่างๆ เข้าไปสำหรับเกมใหม่ ตัวอย่างเช่น พวกเราจะเขียนเลียนแบบของ Old Maid
 Object ของ Old Maid คือ กำจัดไพ่ในมือให้หมดไป คุณทำโดยการจับคู่ rank และ สี ของไพ่ ตัวอย่างเช่น 4 โพธิ์ดำจับคู่กับ 4 ดอกจิก เป็นสีดำทั้งคู่ แจ๊คหัวใจจับคู่กับแจ๊คข้าวหลามตัดซึ่งเป็นสีแดงทั้งคู่
 เมื่อเริ่มเกม แหม่มโพธิ์ดำจะถูกเอาออกไปจาก deck ดังนั้น แหม่มดอกจิกไม่สามารถจับคู่ได้ ไพ่ที่ยังคงเหลือ 51 ใบ ถูกแจกให้กับผู้เล่น หลังจากแจกเสร็จ ผู้เล่นทั้งหมดจับคู่และทิ้งไพ่ที่เป็นไปได้มาก
 เมื่อไม่สามารถจับคู่ได้มากกว่านี้ การเริ่มเล่น ในรอบ แต่ละผู้เล่นหยิบไพ่มา 1 ใบ (ห้ามดู) จากเพื่อนที่ใกล้ที่สุดไปทางซ้ายผู้ซึ่งยังคงมีไพ่ ถ้าเลือกเจอไพ่ที่ตรงกับในมือของผู้เล่น ในที่สุดการจับคู่ที่เป็นไปได้จะเกิดขึ้น จะเหลือเพียงแหม่มดอกจิกในมือของผู้แพ้
 ในเกมจำลองคอมพิวเตอร์ของเรา คอมพิวเตอร์เป็นผู้เล่นทั้งหมด โชคไม่ดีที่ความแตกต่างน้อยมากที่จะแพ้ในเกมจริงๆ ในเกมจริงๆ ผู้เล่นมี Old Maid ต้องพยายามให้ผู้เล่นใกล้เคียงหยิบไพ่นั้นโดยแสดงมันให้มีความเด่นชัดน้อยกว่า หรือ บางทีพลาดที่จะแสดงมันออกมา หรือแม้พลาดและพลาดอีกที่จะแสดงไพ่ออกมา คอมพิวเตอร์จะหยิบอย่างง่ายๆ จากคนข้างๆ โดยการสุ่ม
16.6 OlaMaidHand class.
ผู้เล่น Ola Maid มีความต้องการความสามารถบ้าง ที่เหนือกว่าความสามารถทั่วไปของ Hand เราจะระบุ class ใหม่ OldMaidHand ซึ่งสืบทอดจาก Hand และให้ method ที่เพิ่มขึ้นนี้เรียกว่า removeMatches
 class OldMaidHand(Hand):
 def removeMatches(self):
 count = 0
 originalCards = self.cards[:]
 for card in originalCards:
 match = Card(3 - card.suit, card.rank)
 if match in self.cards:
 self.cards.remove(card)
 self.cards.remove(match)
 print "Hand %s: %s matches %s" % (self.name,card,match)
 count = count + 1
 return count
 เราเริ่มโดยการคัดลอก list ของไพ่ ดังนั้นเราสามารถตรวจการคัดลอกขณะที่กำลังนำไพ่ออกจากต้นฉบับ ตั้งแต่ self.cards ถูกแก้ไขใน loop เราไม่ต้องการใช้มันในการควบคุมสิ่งที่มาขวาง python ค่อนข้างจะสับสน ถ้ามันตรวจสอบ list ที่มีการเปลี่ยนแปลง
 สำหรับไพ่แต่ละใบในมือ เรามองว่าควรจะจับคู่กับอะไรและไปหามัน การจับคู่ไพ่มี rank ที่เหมือนกัน และ suit ที่สีเหมือนกัน expression 3 – card.suit เปลี่ยนโพธิ์ดำเป็นดอกจิก และ ข้าวหลามตัดเป็นหัวใจ คุณควรพอใจในการทำงานของ opposite operation ถ้าการจับคู่ไพ่อยู่ในมือ ไพ่ทั้งสองก็จะถูกทิ้งไป
 ตามตัวอย่างซึ่งพิสูจน์การใช้ removeMatches :
 »> game = CardGame
 »> hand = OldMaidHand("frank")
 »> game.deck.deal([hand], 13)
 »> print hand
 Hand frank contains
 Ace of Spades
 2 of Diamonds
 7 of Spades
 8 of Clubs
 6 of Hearts
 8 of Spades
 7 of Clubs
 Queen of Clubs
 7 of Diamonds
 5 of Clubs
 Jack of Diamonds
 10 of Diamonds
 10 of Hearts
 »> hand.removeMatches
 Hand frank: 7 of Spades matches 7 of Clubs
 Hand frank: 8 of Spades matches 8 of Clubs
 Hand frank: 10 of Diamonds matches 10 of Hearts
 »> print hand
 Hand frank contains
 Ace of Spades
 2 of Diamonds
 6 of Hearts
 Queen of Clubs
 7 of Diamonds
 5 of Clubs
 Jack of Diamonds
 สังเกตว่าไม่มี __init__ method สำหรับ OldMaidGame class เราสืบทอดมันมาจาก Hand
16.7 OldMaidGame class.
ตอนนี้เราสามารถเปลี่ยนความตั้งใจของเราเพื่อเกมด้วยตัวมันเอง OldMaidGame คือ subclass ของ CardGame มี method ใหม่ เรียกว่า play ซึ่งรับค่า list ของผู้เล่นเป็นพารามิเตอร์
 ตั้งแต่ __init__ ถูกสืบทอดจาก CardGame โดย OldMaidGame ใหม่จะบรรจุการแจกไพ่สำรับใหม่
 class OldMaidGame(CardGame):
 def play(self, names):
 # remove Queen of Clubs
 self.deck.removeCard(Card(0,12))
 # make a hand for each player
 self.hands = []
 for name in names :
 self.hands.append(OldMaidHand(name))
 # deal the cards
 self.deck.deal(self.hands)
 print "---------- Cards have been dealt"
 self.printHands
 # remove initial matches
 matches = self.removeAllMatches
 print "---------- Matches discarded, play begins"
 self.printHands
 # play until all 50 cards are matched
 turn = 0
 numHands = len(self.hands)
 while matches < 25:
 matches = matches + self.playOneTurn(turn)
 turn = (turn + 1) % numHands
 print "---------- Game is Over"
 self.printHands
 บางขั้นตอนของเกมได้ถูกแยกไปใน methods ซึ่ง removeAllMatches ข้าม list ของ hands และสร้าง removeMatches ขึ้น
 class OldMaidGame(CardGame):
 def removeAllMatches(self):
 count = 0
 for hand in self.hands:
 count = count + hand.removeMatches
 return count
 count คือ ตัวเก็บสะสมหน่วยความจำตัวเลขที่จับคู่กันที่เพิ่มเข้าไปในแต่ละมือ และ return ค่าผลรวมออกมา
 เมื่อจำนวนตัวเลขที่จับคู่กันถึง 25 ไพ่ทั้ง 50 ใบ ได้ถูกทิ้งไปจากมือแล้ว ซึ่งหมายความว่ามีไพ่หนึ่งใบที่เหลือและเกมจะจบลง 
 ตัวแปร turn เก็บค่า track การเปลี่ยนแปลงของผู้เล่น มันเริ่มที่ 0 และเพิ่มขึ้นทีละ1 ในแต่ละครั้ง เมื่อมันถึง numHands ใน modulus มันจะกลับไปยังที่ 0
 Method playOne รับค่าพารามิเตอร์ที่ระบุถึง turn ที่มันเป็น
 Return value คือจำนวนการจับคู่ที่ทำระหว่าง turn นี้
 class OldMaidGame(CardGame):
 def playOneTurn(self, i):
 if self.hands[i].isEmpty:
 return 0
 neighbor = self.findNeighbor(i)
 pickedCard = self.hands[neighbor].popCard
 self.hands[i].addCard(pickedCard)
 print "Hand", self.hands[i].name, "picked", pickedCard
 count = self.hands[i].removeMatches
 self.hands[i].shuffle
 return count
 ถ้ามือของผู้เล่นว่าง ผู้เล่นจะถูกออกจากเกม ดังนั้นเขาหรือหล่อนไม่ได้ทำอะไร และ return ค่า 0
 อีกอย่างหนึ่ง หนึ่ง turn ประกอบด้วยการหาผู้เล่นคนแรกทางซ้ายซึ่งมีไพ่ การรับไพ่มาจากคนข้างๆ และตรวจดูว่าเข้าคู่หรือไม่ ก่อนจะเวียนไพ่ในมือที่ถูกสับไพ่แล้ว ดังนั้นการเลือกของผู้เล่นคนถัดไปคือการสุ่ม
 Method findNeighbor เริ่มมีผู้เล่นทันทีทางซ้ายและต่อเนื่องเป็นวงกลมจนกระทั้งหาผู้เล่นที่ยังคงมีไพ่
 class OldMaidGame(CardGame):
 def findNeighbor(self, i):
 numHands = len(self.hands)
 for next in range(1,numHands):
 neighbor = (i + next) % numHands
 if not self.hands[neighbor].isEmpty:
 return neighbor
 ถ้า findNeighbor เวียนเป็นวงกลมเรื่อยๆ โดยปราศจากการหาไพ่ มันจะ return ค่า None และเป็นเหตุให้เกิด error ขึ้นในโปรแกรม โชคดีที่เราสามารถตรวจสอบว่าสิ่งนั้นจะไม่เกิดขึ้น
 เราได้ละเลย printHands ไป คุณสามารถเขียน method นี้ด้วยตัวคุณเอง
 ตามผลลัพธ์ที่แสดงออกมาจากรูปแบบที่สั้นลงของเกมซึ่งมีเพียง 15 ใบด้านบนสุด ซึ่งแจกให้ผู้เล่น 3 คน มีสำรับเล็ก โดยหยุดเล่นหลังจากจับคู่ได้ 7 คู่ แทนที่จะเป็น 25 คู่
 »> import cards
 »> game = cards.OldMaidGame
 »> game.play(["Allen","Jeff","Chris"])
 ---------- Cards have been dealt
 Hand Allen contains
 King of Hearts
 Jack of Clubs
 Queen of Spades
 King of Spades
 10 of Diamonds
 Hand Jeff contains
 Queen of Hearts
 Jack of Spades
 Jack of Hearts
 King of Diamonds
 Queen of Diamonds
 Hand Chris contains
 Jack of Diamonds
 King of Clubs
 10 of Spades
 10 of Hearts
 10 of Clubs
 Hand Jeff: Queen of Hearts matches Queen of Diamonds
 Hand Chris: 10 of Spades matches 10 of Clubs
 ---------- Matches discarded, play begins
 Hand Allen contains
 King of Hearts
 Jack of Clubs
 Queen of Spades
 King of Spades
 10 of Diamonds
 Hand Jeff contains
 Jack of Spades
 Jack of Hearts
 King of Diamonds
 Hand Chris contains
 Jack of Diamonds
 King of Clubs
 10 of Hearts
 Hand Allen picked King of Diamonds
 Hand Allen: King of Hearts matches King of Diamonds
 Hand Jeff picked 10 of Hearts
 Hand Chris picked Jack of Clubs
 Hand Allen picked Jack of Hearts
 Hand Jeff picked Jack of Diamonds
 Hand Chris picked Queen of Spades
 Hand Allen picked Jack of Diamonds
 Hand Allen: Jack of Hearts matches Jack of Diamonds
 Hand Jeff picked King of Clubs
 Hand Chris picked King of Spades
 Hand Allen picked 10 of Hearts
 Hand Allen: 10 of Diamonds matches 10 of Hearts
 Hand Jeff picked Queen of Spades
 Hand Chris picked Jack of Spades
 Hand Chris: Jack of Clubs matches Jack of Spades
 Hand Jeff picked King of Spades
 Hand Jeff: King of Clubs matches King of Spades
 ---------- Game is Over
 Hand Allen is empty
 Hand Jeff contains
 Queen of Spades
 Hand Chris is empty
 So Jeff loses.
16.8 Glossary.
inheritance: The ability to define a new class that is a modified version of a previously defined class.
 parent class: The class from which a child class inherits.
 child class: A new class created by inheriting from an existing class; also called a “subclass.”