继承指的是在现有类的基础下进行修改,从而定义新的的类的能力;
下面从一个例子进行介绍什么是继承:
(一)卡牌对象
- 定义一个卡牌的对象:
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'>
**注意:**当使用一个方法覆盖另一个方法的时候,新方法的接口应该与旧方法的接口一致:
- 接受相同的参数;
- 返回相同的类型;
- 遵守相同的先决条件和后置条件;