目录
在讲之前，我想说说中国古代历史。我们都知道在古代，君王的传位是遵循嫡长子继承制的，皇帝的位置一般是传给太子的，那在继承的过程中也就是说皇帝的所有权利以及所拥有的东西都会传给下一个皇帝，但是相关的规矩一般是不会变化的，比如说朝代的国号以及一些重要制度，但是这不代表新皇帝不可以去改革，比如战国时期秦国的商鞅变法。
好了这里讲这么多，我们对“继承”这个词有点理解吧，在Python中也基本上是遵循这样的规则的，废话不多说，一起来看看吧！！！
继承嘛，顾名思义就是后者继承先者的某些特征和属性，比如说：儿子继承老爸的股份，太子继承皇位等等。在Python中，被继承的类叫做父类，继承的类叫做子类，子类继承父类的属性和方法
继承可以解决重复类的代码造成的冗余
继承可以提高代码的复用性
在python中所有的类都继承于object，object就是基类，超类 ，所以object类是所有类的父类
class A:
pass
class B(object):
pass
#object类是所有类的父类，也就是说如果一个类没有指定继承哪个类，那么就会默认继承object类
#所以A和B类都是继承object类，是一样的我们可以去通过dir() 来获取object类具有的方法，如下所示：
class A(object):
def __init__(self,name,age):
self.name=name
self.age=age
a=A('Jack',15)
print(a)
#输出结果：<__main__.A object at 0x00000216806D0460>定义
class Son(Father):
法则
一般来说，子类可以继承父类的属性和方法，但是这些属性和方法都是公有的，不是私有化的，所以父类的私有化属性和方法是继承不了的
示例：
class Oldking(object):
def __init__(self,name,clothes,seal,mausoleum):
self.name=name
self.clothes=clothes
self.seal=seal
self.__mausoleum=mausoleum#私有化属性
def dynasty(self):
print('唐朝')
def __years(self): #私有化方法
print('贞观之治')
class Newking(Oldking):
pass
t=Newking('武则天','龙袍','玉玺','帝陵')
print(t.name,t.clothes,t.seal) #这里无法输出 帝陵，因为被父类私有化了
t.dynasty() #同时也无法所以__years() 方法，这个方法也是私有化了
#输出结果：武则天 龙袍 玉玺
# 唐朝新皇帝可以继承老皇帝的权利，那当然可以进行相关制度的改革，或者说是年号的改革，比如说唐太宗年号为贞观之治，武则天的是贞观遗风。所以我们在Python中子类也可以对父类继承的东西进行重写。
class Old(object):
def __init__(self):
self.king='隋炀帝'
self.clothes='龙袍'
def dynasty(self):
print('这是隋朝')
class New(Old):
def __init__(self):
self.king='唐高祖'
self.clothes=Old().clothes
def dynasty(self):
print('这是唐朝')
t=New()
print(t.king,t.clothes)
t.dynasty()
#输出结果：唐高祖 龙袍
# 这是唐朝这个示例可以看出，重写了朝代和皇帝的名字，然而对龙袍进行了保留继承
多层继承就涉及到父类继承其父类，子类又继承父类,就是一种继承的嵌套,也就是孙子继承父亲的，父亲继承爷爷的。当然在每次继承的过程中也是可以对相关内容进行重写。在继承过程中，属性的查找顺序是先从自身属性去查找，如果找不到就去父类去查找，如果父类还找不到就去爷爷类查找，以此类推……
顺序：对象>子类>父类>父父类
示例：
class Grandpa(object):
def __init__(self):
self.__name='史蒂夫'
self.money=100
def fun(self):
print('传家宝:尚方宝剑')
class Father(Grandpa):
def __init__(self):
self.money=2**10
class Son(Father):
def college(self):
print('GUET')
AJ=Son()
print(AJ.money)
AJ.fun()
AJ.college()
#输出结果：
# 1024
# 传家宝:尚方宝剑
# GUET这个也是很好理解的，如果父类没有特定设置私有化属性的话，子类会一一继承，如果一直嵌套下去的话，到最后子类具有的属性和特点会非常多，这就是一个累积过程。当我们去创建一个实例对象，然后去查找这个实例对象相关属性和方法时，这会依次向父类查找，直到找到为止。
多继承是表示一个子类具继承个父类，也就是说一个儿子有多个父亲(到处认爹) 一个子类继承多个父类的东西。
继承顺序：在继承中出现相同方法则继承顺序是从左到右
示例1：
class Father0(object):
def fun(self):
print('有钱')
class Father1(object):
def fun(self):
print('穷')
class Son0(Father0,Father1):
pass
class Son1(Father1,Father0):
pass
Jack=Son0()
jb=Son1() #输出结果：有钱
Jack.fun()
jb.fun() #输出结果：穷在多继承中，我们可以去通过__mro__方法去查看继承的属性，（从左到右）
示例2：
class G:
pass
class E(G):
pass
class F(G):
pass
class B(E):
pass
class C(F):
pass
class D(G):
pass
class A(B, C, D):
pass
son=A()
print(A.__mro__) #查看相同的方法继承顺序输出结果：
顺序为：A->B->E->G->C->F->D->object
一
在重写多/但继承父类的方法时，但是又想调用父类的方法，这时候就用到super() 方法
super() 方法是按照上面所说的继承顺序来执行的，也就是执行第一个继承的父类的方法
class Sheep(object):
def sound(self):
print('咩咩咩')
class Cat(object):
def sound(self):
print('喵喵喵')
def animal(self):
print('猫咪')
class Dog(Sheep):
def animal(self):
print('小狗')
class A(Dog,Cat):
def sound(self):
print('哈哈哈')
super().sound() #调用(按照顺序)父类的方法
tt=A()
tt.sound()
#输出结果:哈哈哈
# 咩咩咩可能会有些人疑惑，明明Dog没有定义sound() 方法，但是又为什么可以找到呢，其实是Dog继承了Sheep类，是在这里找到了sound() 方法
二
其实如果我们想去直到调用哪一个父类的方法，我们可以直接去声明调用：
父类.方法(self)
class Cat(object):
def sound(self):
print('喵喵喵')
def animal(self):
print('猫咪')
class Dog(object):
def animal(self):
print('小狗')
class A(Dog,Cat):
def sound(self):
Cat.sound(self)####
print('哈哈哈')
tt=A()
tt.sound()
print(A.__bases__)
#输出结果:喵喵喵
# 哈哈哈好了，这一期就到这里了先，我们下一期再见~~~
分享一张壁
