面向对象的三大特性之一--继承（单、多继承，菱形继承、类关系检测 issubclass()）

''
+ 当子类继承父类后，就可以去使用父类中的成员属性和方法 （除了私有成员）
子类可以有自己独立的成员，也可以没有
+ 在不指定继承的父类时，所有类都继承自object类（系统提供） 了解
+ 子类继承父类后，重新定义了父类中的方法，这种情况称为对父类方法的重写
+ 在子类中可以去直接调用父类中定义的方法 super().父类方法名()
+ 子类重写父类的方法，依然可以使用super().父类方法名()的方式调用父类的方法
+ 子类继承父类后，定义类父类中没有的方法，这种情况称为 对父类的 扩展
+ 一个父类可以被多个子类继承，还可以存在 链式继承 。
  + 链式继承：A类继承了B类，B类继承了C类，C类继承了D类。。。
+ 子类调用父类的方法时，如果该方法有参数要求，也需要传递参数
'''

# 猫科动物
class maoke():
    #  属性
    maose = '猫纹'
    sex = 'm'

    #方法
    def pao(self):
        print('run')

    def pa(self):
        print('能上树')

class mao(maoke):
    # 继承父类后，重新定义了父类中的方法
    def pa(self):
        super().pa() # 重写之前可以去直接调用父类中定义的方法 super().父类方法名()
        print('很快就可以爬上树')

    def zhua(self):
        print('喜欢抓老鼠')

# 通过猫类 实例化对象
h = mao()
print(h.__dict__) # {}
# 可以获取对象的属性 猫对象自己的属性 ==> 猫类的属性，===> 继承的父类

print(h.maose)  # 输出：猫纹

# 调用对象的方法
h.pao() # 输出：run
h.pa() # 输出：能上树 因为前面用了super().父类方法名()
             #很快就可以爬上树
h.zhua() # 输出：喜欢抓老鼠

单继承和多继承

单继承：一个类只能继承一个父类的方式。
       一个父类可以被多个子类继承，还可以存在 链式继承 。
       链式继承：A类继承了B类，B类继承了C类，C类继承了D类。
语法格式：
class 父类():
	pass
	
class 子类(父类):
	pass
       
多继承：一个类去继承多个父类的方式。
语法格式：
class 父亲():
	pass
	
class 母亲():
  pass
  
class 子类(父亲,母亲):

菱形继承

#### 菱形继承（钻石继承）

    A
  B   C
    D
# D类去继承了B类和C类，然后B类和C类又分别继承了A类，这种继承关系称为 菱形继承
 D---B---C---A


问题：在这种菱形继承关系中，类与类的关系，及super()调用时的顺序

# 祖先类
class HuMan():
    num = 444
    def eat(self):
        print(self.num) # 4.开始输出，这个时候的对象指的是最开始发起的那个，所以输出111
        print('顿顿都是小烧烤。。。') # 5.输出

# 父亲类
class F(HuMan):
    num = 333
    def eat(self):
        super().eat() # 2.跳到 M
        print(super().num) 8.回到F，输出F的上一级，输出222
        print('大口喝酒，大口吃肉。。。') 9.继续输出

# 母亲类
class M(HuMan):
    num = 222
    def eat(self):
        super().eat() # 3.跳到HuMan
        print(super().num) # 6.回到M,继续输出，这时候只的是父类的num，输出444
        print('动作优雅，浅尝即止') # 7.继续输出

# 孩子类
class C(F,M):
    num = 111
    def eat(self):  #开始：
        super().eat()   # 1.跳到父类F
        print(super().num) 10.回到C，输出父类的num，为333
        print('吃也哭，不吃也哭。。。') 11.继续输出，程序跑完

# 实例化对象C-F-M-HuMan
c = C()
c.eat()

输出结果：

111   
顿顿都是小烧烤。。。
444
动作优雅，浅尝即止
222
大口喝酒，大口吃肉。。。
333
吃也哭，不吃也哭。。。

'''
在定义类后，程序会自动生成一个继承的列表 MRO （Method Realtion Order） 方法关系列表
MRO列表生成原则：
	1. 子类永远在父类的前面
	2. 同一等级的类，按照子类中的继承顺序摆放
	3. 先子类，后父类的顺序原则，最终的类时系统提供的object类
MRO的调用方法
类名.mro()
'''
C.mro()
# [<class 'C'>, <class 'F'>, <class 'M'>, <class 'HuMan'>, <class 'object'>]

# super()在调用时，并不是查找父类，而是去MRO列表上找上一个类。
# super()方法在调用时，会自动把当前self传入到上一级的类的方法中

类关系检测 issubclass()

# issubclass() 检测一个类是否时另一个类的子类
# 检测一个类是否是另一个类的子类
res = issubclass(D,B) # True 检测D类是不是B类的子类
res = issubclass(D,C) # True 检测D类是不是C类的子类
res = issubclass(D,A) # True 检测D类是不是A类的子类
res = issubclass(A,D) # False 检测A类是不是D类的子类
print(res)