继承是一种创建新类的方式；
在Python中，新建的类可以继承一个或多个父类，新建的类可称为子类或派生类，父类又可称为基类或超类。
继承可以用来解决类与类之间的代码重用性问题；
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承
pass
class SubClass2(ParentClass1,ParentClass2): #多继承
pass注意：
在python中一个子类可以继承多个父类，在其他语言中，一个子类只能继承一个父类；
python中的继承分为单继承和多继承；
通过类的内置属性__bases__可以查看类继承的所有父类
>>> SubClass2.__bases__ (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
在Python3中只有新式类，即使没有显式地继承object，也会默认继承该类。
子类继承父类的成员变量和成员方法：
示例：
# python中子类继承父类成员变量之间的取值逻辑
class Person():
def __init__(self, name, age, sex):
self.name = "jasn"
self.age = '18'
self.sex = sex
def talk(self):
print("i want to speak something to yo!!")
class Chinese(Person):
def __init__(self, name, age, sex, language):
Person.__init__(self, name, age, sex) # 用父类的name,age，sex 覆盖掉子类的属性
self.age = age # 覆盖掉了父类的age,取值为子类实例中传入age参数
self.language = "chinese"
def talk(self):
print("我说的是普通话！！")
Person.talk(self)
obj = Chinese("nancy",'18','male',"普通话")
print(obj.name) # 对应场景A
print(obj.age) # 对应场景B
print(obj.language) # 对应场景C
obj.talk() # 对应场景D
# 总结：
# A:若父类中初始化了成员变量，子类调用父类构造方法未覆盖属性（self.name），则调用子类属性时取值为父类中初始化的成员变量；
# B:若父类中初始化了成员变量，若子类调用父类构造方法覆盖属性（self.age）则取值为子类实例中传入参数
# C:若父类未初始化该成员变量，则无论子类中有无进行对父类构造方法进行属性的覆盖，均取子类实例中传入的参数
# D:对于方法,如果子类有这个方法则直接调用，如果子类没有则去父类查找。父类没有则报错对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表。
>>> D.mro() # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置方法 [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止，而这个MRO列表的构造是通过一个C3线性化算法来实现的。
实际上就是合并所有父类的MRO列表并遵循如下三条准则：
Python 中的 MRO —— 方法搜索顺序
Python中针对类提供了一个内置属性 mro 可以查看方法搜索顺序
MRO 是 method resolution order，主要用于在多继承时判断方法、属性 的调用路径。
print(C.__mro__) #C是多继承后的类名
输出结果：
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
在搜索方法时，是按照 mro 的输出结果 从左至右 的顺序查找的；
如果在当前类中找到方法，就直接执行，不再搜索；如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索。
如果找到最后一个类，还没有找到方法，程序报错。
（1）多继承结构为菱形结构
如果继承关系为菱形结构，那么经典类与新式类会有不同MRO。
箭头表示搜索顺序
（2）多继承结构为非菱形结构
会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性。
① 由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去。
② 由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去。
主要知识点：类的__mro__ 属性的用法；
有了继承关系，对象在查找属性时，先从对象自己的__dict__中找，如果没有则去子类中找，然后再去父类中找.....
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
b=Bar()
b.f2()
# 运行结果：
Foo.f2
Bar.f1
# 运行流程分析：
b.f2()会在父类Foo中找到f2，先打印Foo.f2,然后执行到self.f1(),即b.f1()，仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去，在类Bar中找到f1，因而打印结果为Bar.f1父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的：
class Foo:
def __f1(self): # 变形为_Foo__f1
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.__f1() # 变形为self._Foo__f1,然后回到Bar类中找，没有，再到Foo中找到了
class Bar(Foo):
def __f1(self): # 变形为_Bar__f1
print('Bar.f1')
b=Bar() # Bar类处于执行阶段，_Bar__f1变为__f1
b.f2() # 在父类中找到f2方法，进而调用b._Foo__f1()方法，是在父类中找到的f1方法
# 运行结果：
Foo.f2
Foo.f1方式主要有2类：
① 实现继承是指使用基类的属性和方法而无需额外编码的能力。
② 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。
例如：Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类，但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
父类中的私有方法和私有属性都是不能被子类继承下来的；
测试示例：父类中的私有属性和私有方法是否能被继承下来？
class Perpon:
num = 20
__num1 = 12
def __test1(self):
print('__test1....')
def test2(self):
print('test2...')
class Student(Perpon):
def test(self):
print('num...')
print(self.num)
# print(Student.__num1)
self.test2()
# self.__test1()
student = Student()
student.test()
student.test2()
# student.__test1() # 报错
'''
num...
20
test2...
test2...
'''1）在父类的基础上产生子类，产生的子类就叫做派生类
2）父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。
3）父类里有，子类也有的方法，就叫做方法的重写（就是把父类里的方法重写了)
class Hero:
def __init__(self, nickname,aggressivity,life_value):
self.nickname = nickname
self.aggressivity = aggressivity
self.life_value = life_value
def attack(self, enemy):
print('Hero attack')
class Garen(Hero):
camp = 'Demacia'
def attack(self, enemy): #self=g1,enemy=r1
# self.attack(enemy) #g1.attack(r1)，这里相当于无限递归
Hero.attack(self,enemy) # 引用 父类的 attack，对象会去跑 父类的 attack
print('from garen attack') # 再回来这里
def fire(self):
print('%s is firing' % self.nickname)
class Riven(Hero):
camp = 'Noxus'
g1 = Garen('garen', 18, 200)
r1 = Riven('rivren', 18, 200)
g1.attack(r1)
# print(g1.camp)
# print(r1.camp)
# g1.fire()子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）；
需要注意的是：一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了(属性的覆盖)。
示例：
# 派生属性: 子类中自己添加的新属性
# 属性的覆盖: 子类和父类有相同属性,调用自己的
class Perpon:
num = 20
def __init__(self, name):
print('person...')
class Student(Perpon):
num = 10 # 把父类中的20覆盖
def __init__(self, name, age): # age 为派生属性
super().__init__(name)
self.name = name
self.age = age
print('student...')
def study(self):
print(super().num)
pass
student = Student('赵四', 23)
print(student.name) # person...
print(student.age)
print(student.num)
student.study()
'''
person...
student...
赵四
23
10
20
'''指名道姓的重用
class A:
def __init__(self):
print('A的构造方法')
class B(A):
def __init__(self):
print('B的构造方法')
A.__init__(self)
class C(A):
def __init__(self):
print('C的构造方法')
A.__init__(self)
class D(B,C):
def __init__(self):
print('D的构造方法')
B.__init__(self) # 先找到B，B调用A，等这个线性任务处理完之后，在继续下一行代码
C.__init__(self) # 先找到C，C里面也调用A的方法
pass
f1=D() #A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''Super()方法重用
class A:
def __init__(self):
print('A的构造方法')
class B(A):
def __init__(self):
print('B的构造方法')
super(B,self).__init__()
class C(A):
def __init__(self):
print('C的构造方法')
super(C,self).__init__()
class D(B,C):
def __init__(self):
print('D的构造方法')
super().__init__() # super(D,self).__init__()
f1=D() #super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''
# super() 语法
# super(type[, object-or-type]) type 当前类，object-or-type 为实例化对象，一般默认为self,不过该参数在python3中默认super（）是一个特殊的类，调用super得到一个对象，该对象指向父类的名称空间。
派生与继承解决问题：子类重用父类的属性，并派生出新的属性。
注意：使用哪一种都可以，但不能两种方式混合使用！
可以将一些共用的功能加在基类中,实现代码的共享；
在不改变基类的基础上改变原有的功能；
练习：
list类里只有append向末尾加一个元素的方法,但没有向列表头部添加元素的方法，试想能否为列表在不改变原有功能的基础上添加一个inster_head(x)方法,此方法能在列表的前部添加元素？
class Mylist(list):
def insert_head(self,x):
# self.reverse()
# self.append(x)
# self.reverse()
self.insert(0,x) #直接在最开始插入x
myl = Mylist(range(3,6))
print(myl) #[3.4.5]
myl.insert_head(2)
print(myl) #[2,3,4,5]
myl.append(6)
print(myl) #[2,3,4,5,6]super(cls,obj)返回被绑定超类的实例(要求obj必须为cls类型的实例)
super() 返回被绑定超类的实例,等同于:super(class,实例方法的第一个参数,必须在方法内调用)
格式：
父类类名.方法名称(self) 或者 super().方法名称()或者super(本类类名,对象名)
作用：借助super()返回的实例间接调用父类的覆盖方法；
示例：
#此示例示意用super函数间接调用父类的
class A:
def work(self):
print('A.work被调用')
class B(A):
'''B类继承子A类'''
def work(self):
print('B.work被调用')
def super_work(self):
#调用b类自己的work方法
self.work()
#调用父类的work
super(B,self).work()
super().work() #此种调用方式只能在实例方法内调用
b = B()
# b.work() #B.work被调用!!
# super(B,b).work() #A.work被调用
b.super_work()
# super_work() #出错调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且继承顺序严格遵循mro继承序列；
示例：
class Father1:
x =10
pass
class Father2:
x = 20
pass
#多继承的情况下，从左到右
class Sub(Father1,Father2):
def __init__(self): #注意__int__不是__init__
print(super().__delattr__)
print(Sub.mro()) # [<class '__main__.Sub'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class 'object'>]
obj = Sub()
print(object) #<class 'object'>mro()：会把当前类的继承关系列出来，严格按照mro列表的顺序往后查找
class A: #默认继承object
def test(self):
print('from A.test')
super().test()
class B:
def test(self):
print('from B.test')
class C(A, B):
pass
c = C()
#检查super的继承顺序
#mro(): 会把当前类的继承关系列出来。
print(C.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
c.test() #from A.test
#from B.test使用super调用父类中的方法，注意分析程序的执行顺序。
class Parent(object):
def __init__(self, name, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('parent的init开始被调用')
self.name = name
print('parent的init结束被调用')
class Son1(Parent):
def __init__(self, name, age, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('Son1的init开始被调用')
self.age = age
super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print('Son1的init结束被调用')
class Son2(Parent):
def __init__(self, name, gender, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print('Son2的init开始被调用')
self.gender = gender
super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print('Son2的init结束被调用')
class Grandson(Son1, Son2):
def __init__(self, name, age, gender):
print('Grandson的init开始被调用')
# 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍
# 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
# super(Grandson, self).__init__(name, age, gender) 效果和下面的一样
super().__init__(name, age, gender)
print('Grandson的init结束被调用')
print(Grandson.__mro__) #搜索顺序
gs = Grandson('grandson', 12, '男')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
'''结果如下：
(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)
Grandson的init开始被调用
Son1的init开始被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名：grandson
年龄：12
性别：男
'''注意：在上面模块中，当在子类中通过super调用父类方法时，parent被执行了1次。
super调用过程：上面gs初始化时，先执行grandson中init方法, 其中的init有super调用，每执行到一次super时，都会从__mro__方法元组中顺序查找搜索。
所以先调用son1的init方法，在son1中又有super调用，这个时候就就根据__mro__表去调用son2的init，然后在son2中又有super调用，这个就根据mro表又去调用parent中的init，直到调用object中的init。
所以上面的打印结果如此，要仔细分析执行过程。
重点提示：
这也是为何多继承需要全部传参的一个原因
练习一
子类调用自己的方法的时候同时调用父类的方法
class Dog(Animal):
def sleep(self):
# 方法一 父类.方法名(对象)
# Animal.eat(self)
# 方法二 super(子类,对象名).方法名()
super(Dog,dog).sleep()
print('去狗窝')
def look_door(self):
print('看门狗')
dog = Dog('哈巴狗',23)
dog.sleep()
'''
睡觉
去狗窝
'''练习二
在类的外部调用super()
# 类外部调用super()
dog = Dog('哈巴狗', 23)
super(Dog, dog).sleep() # super(子类,对象名).方法名()
dog.sleep()
'''
睡觉
去狗窝
'''
