面对对象--继承
一：什么是继承：
在opp程序设计中， 当我们定义一个class的时候， 可以从某个现有的class继承， 新的class称为子类（Subclass），而被继承的class称为基类， 父类或者超类
1 class Card: #定义了一个父类
2 def __init__(self, rank, suit): #rank poker的序号 suit class Suit的对象
3 self.rank = rank #poker 的序号
4 self.suit = suit #Suit类有两个属性 'Club', '♣'
5 print(self.rank, self.suit.name, self.suit.symbol)
6 class NumberCard(Card): #当序号是数字的时候调用这个类
7 def __init__(self, rank, suit):
8 super(NumberCard, self).__init__(str(rank), suit) #继承父类种的__init__构建函数
9
10 class AceCrad(Card): #当序号为A时候调用
11 def __init__(self, rank, suit):#这里还有一种不写init构建函数就会自动去父类，以及超类去找
12 super().__init__('A', suit)
13 class FaceCrad(Card): #当序号为JQK的时候调用
14 def __init__(self, rank, suit):
15 super().__init__({11:'J', 12:'Q', 13:'K'}[rank], suit)
16
17 class Suit:
18 '''四种花色的构建'''
19 def __init__(self, name, symbol):
20 self.name = name
21 self.symbol = symbol
22
23
24 # 梅花， 方片， 红心， 黑桃 实例化一个花色的对象
25 Club, Diamond, Heart, Speade = Suit('Club', '♣'), Suit('Diamond', '♦'), Suit('Heart', '❤'), Suit('Spade', '♠')
程序分析：这是一个poker类的创建， 代码来自python面对对象指南一书修改。
1：程序构建了卡牌的类， 一副扑克有52个牌，13种数字， 4种花色。 13种数字纯数字有2到10 ，其他AJQK
2：那么就定义了3个类分别创建纯数字， A， JQK。 他们统一继承父类Card
3：最后创建了一个类构建四种花色
1 def card10(rank, suit):#定义一个函数接收两个参数 牌号， 花色类对象（每种花色一个对象）
2 if rank == 1: return AceCrad(rank, suit)
3 elif 2<= rank < 11: return NumberCard(rank, suit)
4 elif 11<= rank < 14: return FaceCrad(rank, suit)
5 else:
6 raise Exception('Rank out of range')
7 deck10 = [card10(rank, suit)
for rank in range(1,14)
for suit in (Club, Diamond, Heart, Speade)] #列表推导式实现52张牌的实例化
二：子类和父类的关系
2.1 继承： 父类， 超类， 基类
子类： 也叫派生类
父类中所有的属性和方法都可以被子类使用， 在子类中调用方法时，先在子类的对象空间找， 找不到就会父类，子类找到的，父类方法则不会运行。
2.2 我们如何执行父类方法
1：父类名 和 方法名
2：super ：super（）自动传进去self， 加点执行父类中的方法
1 class A:
2 def __init__(self):
3 print('来了吗')
4 def func(self):
5 print('super加点执行父类的方法')
6 class B(A):
7 def __init__(self):
8 super().func()
9 b = B() #super加点执行父类的方法
3：slef
当self去掉用那个方法时候， 不要看self在哪个类里， 要看self是传进来的那个类， 先去自己的类去找， 找不到再去父类
4：继承与派生
子类在父类的基础上又创建了自己的方法和属性
父类有的子类没有， 子类对象就会直接调用父类的方法和属性，父类有子类也有始终调用自己的。
5：抽象类：规范的编程模式
可能会在工作中使用抽象类的规则，看一些源码的时候别人使用抽象类，它是一种规范， 基本上不会去实现功能， 不能被实例
规范：多人开发， 复杂的需求， 后期的扩展， 这时候就需要一种编程规范， 抽象类可以帮助我们更好的管理。
三：新式类
在python 3.x 版本中所有的类都是新式类，新式类都有一个默认的父类：object
1 class Up:
2 def fun(self):
3 print('Up')
4 class Down(Up):
5 def fun(self):
6 super().fun()
7 print('Down!')
8 class Left(Up):
9 def fun(self):
10 super().fun()
11 print('Left!')
12 class Right(Down, Left):
13 def fun(self):
14 super().fun()
15 print('Right')
16 Right().fun() #Up-->Left->Down -->Right
17 print(Right.mro()) #[<class '__main__.Right'>, <class '__main__.Down'>, <class '__main__.Left'>,\
<class '__main__.Up'>, <class 'object'>]
新式类中：
1：所有的多继承关系寻找方法发的顺序 遵循广度优先算法
2：继承object
3：mro(对象寻找方法的顺序， 严格按照mro寻找)
4：super：super不是单纯的找父类， 而是遵循mro顺序的
经典类：
1：python 2.x
2：不主动继承object
3：经典类在父类中的方法的过程中 遵循 深度优先搜索(一条路走到黑)
4：不提供mro方法和super
