面对对象--继承

一：什么是继承：

　　　　　　在opp程序设计中， 当我们定义一个class的时候， 可以从某个现有的class继承， 新的class称为子类（Subclass），而被继承的class称为基类， 父类或者超类

　　　　　　

class Card: #定义了一个父类
    def __init__(self, rank, suit): #rank poker的序号  suit class Suit的对象
        self.rank = rank #poker 的序号
        self.suit = suit #Suit类有两个属性 'Club', '♣' 
        print(self.rank, self.suit.name, self.suit.symbol)
class NumberCard(Card): #当序号是数字的时候调用这个类
    def __init__(self, rank, suit):
        super(NumberCard, self).__init__(str(rank), suit) #继承父类种的__init__构建函数

class AceCrad(Card): #当序号为A时候调用
    def __init__(self, rank, suit):#这里还有一种不写init构建函数就会自动去父类，以及超类去找
        super().__init__('A', suit)
class FaceCrad(Card): #当序号为JQK的时候调用
    def __init__(self, rank, suit):
        super().__init__({11:'J', 12:'Q', 13:'K'}[rank], suit)

class Suit:
    '''四种花色的构建'''
    def __init__(self, name, symbol):
        self.name = name
        self.symbol = symbol


# 梅花， 方片， 红心， 黑桃  实例化一个花色的对象
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：最后创建了一个类构建四种花色

　　

def card10(rank, suit):#定义一个函数接收两个参数 牌号， 花色类对象（每种花色一个对象）
    if rank == 1: return AceCrad(rank, suit)
    elif 2<= rank < 11: return NumberCard(rank, suit)
    elif 11<= rank < 14: return FaceCrad(rank, suit)
    else:
        raise Exception('Rank out of range')
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， 加点执行父类中的方法

　　　　　　

class A:
    def __init__(self):
        print('来了吗')
    def func(self):
        print('super加点执行父类的方法')
class B(A):
    def __init__(self):
        super().func()
b = B() #super加点执行父类的方法

　　　　　　3：slef 

　　　　　　　　　　当self去掉用那个方法时候， 不要看self在哪个类里， 要看self是传进来的那个类， 先去自己的类去找， 找不到再去父类

　　　　　　4：继承与派生

　　　　　　　　　子类在父类的基础上又创建了自己的方法和属性

　　　　　　　　　父类有的子类没有， 子类对象就会直接调用父类的方法和属性，父类有子类也有始终调用自己的。

　　　　　　5：抽象类：规范的编程模式

　　　　　　　　可能会在工作中使用抽象类的规则，看一些源码的时候别人使用抽象类，它是一种规范， 基本上不会去实现功能， 不能被实例

　　　　　　　规范：多人开发， 复杂的需求， 后期的扩展， 这时候就需要一种编程规范， 抽象类可以帮助我们更好的管理。

三：新式类

　　在python 3.x 版本中所有的类都是新式类，新式类都有一个默认的父类：object

　　

class Up:
    def fun(self):
        print('Up')
class Down(Up):
    def fun(self):
        super().fun()
        print('Down!')
class Left(Up):
    def fun(self):
        super().fun()
        print('Left!')
class Right(Down, Left):
    def fun(self):
        super().fun()
        print('Right')
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