继承
1.继承初识
如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。
2.继承的优点
继承的优点也是显而易见的：
1，增加了类的耦合性（耦合性不宜多，宜精）。
2，减少了重复代码。
3，使得代码更加规范化，合理化。
3.单继承和多继承
单继承
1.类名执行父类属性方法
class Animal:
live = "有生命的"
def __init__(self, name, sex, age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print("会吃")
class Human(Animal):
body = "有头有脸"
print(Human.live)
Human.eat(123)
2.对象执行父类属性方法
class Animal:
live = "有生命的"
def __init__(self, name, sex, age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print("会吃")
class Human(Animal):
live = "有思想的活着"
body = "有头有脸"
liye = Human("李业", "男", 18)
print(liye.live)
liye.eat()
3.在子类中既执行子类方法,又执行父类方法
不依赖继承的方法
class Animal:
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def eat(self):
print("动物都需要吃饭")
class Human:
def __init__(self, name, sex, age, hobby):
Animal.__init__(self, name, sex, age)
self.hobby = hobby
def eat(self):
super().eat()
print(f"{self.name}都需要吃饭")
obj = Human("李业", "男", 23, "旅游")
print(obj.hobby)
依赖继承的方法
class Animal:
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def eat(self):
print("动物都需要吃饭")
class Human(Animal):
def __init__(self, name, sex, age, hobby):
super().__init__(name, sex, age)
self.hobby = hobby
def eat(self):
super().eat()
print(f"{self.name}都需要吃饭")
obj = Human("李业", "男", 23, "旅游")
print(obj.hobby)
多继承
在python2x版本中存在两种类.：
⼀个叫经典类. 在python2.2之前. ⼀直使⽤的是经典类. 经典类在基类的根如果什么都不写.
⼀个叫新式类. 在python2.2之后出现了新式类. 新式类的特点是基类的根是object类。
python3x版本中只有一种类：
python3中使⽤的都是新式类. 如果基类谁都不继承. 那这个类会默认继承 object
经典类
不继承object类, 深度优先原则
新式类
新式类:继承object类. mro(C3)算法
经典类的深度优先
class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
class E:
pass
class F(D, E):
pass
class G(F, D):
pass
class H:
pass
class Foo(H, G):
pass
Foo-> H -> G -> F -> E -> D -> B -> A -> C
新式类的mro(c3)算法
如果继承至一个基类：class B(A)
这时B的mro序列为:
mro( B ) = mro( B(A) )
= [B] + merge( mro(A) + [A] )
= [B] + merge( [A] + [A] )
= [B,A]
如果继承至多个基类：class B(A1, A2, A3 …)
这时B的mro序列
mro(B) = mro( B(A1, A2, A3 …) )
= [B] + merge( mro(A1), mro(A2), mro(A3) ..., [A1, A2, A3] )
= ...
表头和表尾
表头：
列表的第一个元素
表尾：
列表中表头以外的元素集合（可以为空）
示例
列表：[A, B, C]
表头是A，表尾是B和C
+ 操作
[A] + [B] = [A, B]
（以下的计算中默认省略）
merge示例
如计算merge( [E,O], [C,E,F,O], [C] )
有三个列表 ： ① ② ③
1 merge不为空，取出第一个列表列表①的表头E，进行判断
各个列表的表尾分别是[O], [E,F,O]，E在这些表尾的集合中，因而跳过当前当前列表
2 取出列表②的表头C，进行判断
C不在各个列表的集合中，因而将C拿出到merge外，并从所有表头删除
merge( [E,O], [C,E,F,O], [C]) = [C] + merge( [E,O], [E,F,O] )
3 进行下一次新的merge操作 ......
计算mro(A)方式：
mro(A) = mro( A(B,C) )
原式= [A] + merge( mro(B),mro(C),[B,C] )
mro(B) = mro( B(D,E) )
= [B] + merge( mro(D), mro(E), [D,E] ) # 多继承
= [B] + merge( [D,O] , [E,O] , [D,E] ) # 单继承mro(D(O))=[D,O]
= [B,D] + merge( [O] , [E,O] , [E] ) # 拿出并删除D
= [B,D,E] + merge([O] , [O])
= [B,D,E,O]
mro(C) = mro( C(E,F) )
= [C] + merge( mro(E), mro(F), [E,F] )
= [C] + merge( [E,O] , [F,O] , [E,F] )
= [C,E] + merge( [O] , [F,O] , [F] ) # 跳过O，拿出并删除
= [C,E,F] + merge([O] , [O])
= [C,E,F,O]
原式= [A] + merge( [B,D,E,O], [C,E,F,O], [B,C])
= [A,B] + merge( [D,E,O], [C,E,F,O], [C])
= [A,B,D] + merge( [E,O], [C,E,F,O], [C]) # 跳过E
= [A,B,D,C] + merge([E,O], [E,F,O])
= [A,B,D,C,E] + merge([O], [F,O]) # 跳过O
= [A,B,D,C,E,F] + merge([O], [O])
= [A,B,D,C,E,F,O]
简单方法
print(A.mro())
# [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class '__main__.O'>, <class 'object'>]