【Think Python】Python笔记（十八）继承

继承指的是在现有类的基础下进行修改，从而定义新的的类的能力；

下面从一个例子进行介绍什么是继承：

（一）卡牌对象

• 定义一个卡牌的对象：

class Card:
    """代表一张标准的卡牌
    """
    def __init__(self, suit=0, rank=2):
        self.suit = suit
        self.rank = rank

• 定义一个对象：

queen_of_diamonds = Card(1, 12)

（二）类属性

• 为了让大家可以轻松看懂卡牌对象，可以定义一个从整数码到对应的等级和花色的映射；
• 一种直接的方式是使用字符串列表：

# inside class Card
	suit_names = ['Clubs', 'Diamonds', 'Hearts', 'Spades']
    rank_names = [None, 'Ace', '2', '3', '4', '5', '6', '7',
              '8', '9', '10', 'Jack', 'Queen', 'King']
    
    def __str__(self):
        return '%s of %s' % (Card.rank_names[self.rank],
                            Card.suit_names[self.suit])

• suit_names和rank_names这样的变量，定义在类的内部但是方法之外，称之为类属性；

• 当然也可以使用一个字典来代替列表；

• 使用现有的方法可以创建和打印卡牌：

>>> card1 = Card(2, 11)
>>> print(card)
Jack of Hearts

（三）比较卡牌

• 对于内建类型，可以使用关系运算符（>, <, =）可以比较值；
• 对于自定义的类型，可以使用一个叫做__lt__的方法，覆盖内建运算符的行为；
• __lt__接受两个参数，self和other，如果self比other小，则返回True；

• 编写__lt__:

# inside class Card:
	def __lt__(self, other):
        # 判断花色
        if self.suit < other.suit : return True
        if self.suit > other.suit : return False
        
        # 花色相同，判断等级
        return self.rank < other.rank

• 使用元组类型进行上面的比较：

# inside class Card:
	def __lt__(self, other):
        t1 = self.suit, self.rank
        t2 = other.suit, other.rank
        return t1<t2

（四）定义一副牌

• 下面进行一副牌的定义：

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)

（五）打印一副牌

• 定义Deck类的__str__方法：

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

• 一种累积大量字符串的方法：建立一个字符串列表，使用字符串方法join;
• 内建函数str会调用每个卡牌的__str__方法， 并放回它们的字符串表示：

>>> deck = Deck()
>>> print(deck)
Ace of Clubs
2 of Clubs
3 of Clubs
...
10 of Spades
Jack of Spades
Queen of Spades
King of Spades

（六）添加，移除，洗牌和排序

• 发牌：

# inside class Deck
	# pop从列表中的最后一个元素
	def pop_card(self):
        return self.cards.pop()

• 添加:

# inside class Deck
	def add_card(self, card):
        self.cards.append(card)

• 洗牌：

# inside class Card:
	
    def shuffle(self):
        random.shuffle(self.cards)

（七）继承

**继承：**指的是在现有类的基础上进行修改，从而定义新类的能力；

• 类之间有相似之处，但是也存在不同，可以使用继承：【定义新的类的时候，将现有的类放在括号中】

class Hand(Deck):
    """Represents a hand of playing cards."""

这个定义表明：Hand继承自Deck，可以对Hand使用Deck的pop_card和add_card方法；

• 当一个新类继承自一个现有的类的时候，现有的类称之为父类，新的类称之为子类；

• 但是这里同样继承了__init__方法，我们需要重新定义一个__init__方法，从而覆盖之前继承的该方法：

# inside class Hand:
	
    def __init__(self, label=''):
        self.cards = []
        self.label = label

>>> hand = Hand('new hand')
>>> hand.cards
[]
>>> hand.label
'new hand'

可以使用pop_card和add_card方法进行发牌的操作：

>>> deck = Deck()
>>> card = deck.pop_card()
>>> hand.add_card(card)
>>> print(hand)
King of Spades

• 将上述代码封装：

# inside class Deck:
	def move_cards(self, hand, num):
        for i in range(num):
            hand.add_card(self.pop_card())

• 继承有利于代码复用；有些情况下，继承更加符合真实的问题结构，使得问题更加容易理解；
• 但是继承使得可读性下降；

（八）类图

类图：是程序结构的一种更加抽象的表达，显示了类与类之间的关系，而不是独立的对象；

• 类之间的关系：
  • 一个类中的对象可以包含对另一个类的对象的引用；如矩形包含对点的引用；
  • 一个类可能继承自另外一个类；
  • 一个类可能依赖于另外一个类：前者中的对象接受后者中的对象作为参数，或者使用后者中的对象作为计算的一部分；

​ 这里，空心三角形表示继承；标准箭头表示引用（代表Deck中包含多少Card）；使用虚线箭头表示依赖；

（九）数据封装

• 之前的类，如点、矩形、时间，都是在现实世界中有明显的对应关系；
• 有时候很难界定需要的对象以及他们之间怎样进行交互，这时候，不同于之前的封装和泛化，使用 数据封装 编写接口类；

• 下面的例子：

class Markov:
    def __init__(self):
        self.suffix_map = {}
        self.prefix = ()

• 将函数转变为方法：

def process_word(self, word, order=2):
    if len(self.prefix) < order:
        self.prefix += (word,)
        return

    try:
        self.suffix_map[self.prefix].append(word)
    except KeyError:
        # if there is no entry for this prefix, make one
        self.suffix_map[self.prefix] = [word]

    self.prefix = shift(self.prefix, word)

改变程序——改变设计但是保持功能不变——这个是代码重构的一种方法；

• 设计对象和方法的开发计划：
  • 首先编写读取全局变量的函数（如有必要）；
  • 程序可以运行之后，找出全局变量和函数之间的关系；
  • 封装相关变量作为对象的属性；
  • 转换相关函数为新的方法；

（十）调试

继承会使得调试变得复杂，因为不知道实际调用的是哪个类的方法；

• 当不确定程序的执行流程，最简单的方法是在相关方法的开始的地方添加print语句，
  • 如果 Deck.shuffle 打印一条如像 Running Deck.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 'Card.Deck'>

**注意：**当使用一个方法覆盖另一个方法的时候，新方法的接口应该与旧方法的接口一致：

• 接受相同的参数；
• 返回相同的类型；
• 遵守相同的先决条件和后置条件；