day26 - 面向对象 继承、属性查找、菱形问题、Mixins
一:继承
1.什么是继承?
继承是一种新建类的方式,新建的类称之为
子类
,被继承的类称之为父类、基类、超类
Python是支持多继承的,一个子类(儿子)可以有多个父类(爸爸)
细思极恐
class Parent1:
pass
class Parent2:
pass
class Sub1(Parent1):
pass
class Sub2(Parent1,Parent2):
pass
print(Sub1.__bases__) # 类/对象.__bases__可以查看继承的父类(基类)
# (<class '__main__.Parent1'>,)
print(Sub2.__bases__)
# (<class '__main__.Parent1'>, <class '__main__.Parent2'>)
2.继承 与 抽象
要找出类与类之间的继承关系,需要先抽象,再继承。抽象即总结相似之处,总结对象之间的相似之处得到类,总结类与类之间的相似之处就可以得到父类,如下图所示
基于抽象的结果,我们就找到了继承关系
上面2张图可以看出:类与类之间的继承指的是:
什么 是 什么
的关系(金毛和二哈是狗,蜻蜓和蜜蜂是昆虫,金鱼和鲑鱼是鱼)子类可以继承(遗传)父类的所有属性(金毛和二哈有狗的特征,而狗和昆虫、鱼都拥有生物的特征)
因而继承可以用来解决类与类之间的代码重用性(冗余)问题
3.为何要继承?
子类会遗传父类的属性,所以:继承是用来解决类于类之间 代码冗余问题
4.如何实现继承?
方法1:指名道姓地调用某一个类的函数
特点:不依赖于继承关系
class People:
school = "Tinghua"
# 空对象,'xxq', 18, 'male'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
class Student(People):
# 空对象,'xxq', 18, 'male', 37, "Python全栈"
def __init__(self, name, age, gender, stu_id, course):
People.__init__(self, name, age, gender) # People.__init__(空对象,'xxq', 18, 'male')
self.stu_id = stu_id
self.course = course
def choose(self):
print('%s 正在选课' % self.name)
class Teacher(People):
def score(self, stu, num):
stu.num = num
stu1 = Student('xxq', 18, 'male', 37, "Python全栈")
print(stu1.school, stu1.name, stu1.age, stu1.gender)
# Tinghua xxq 18 male
方法2:调用super(自己的类名, self)
会返回一个特殊的对象super(自己的类名, self).属性
会参照属性查找发起的那个类的mro列表去它父类中查找属性
特点:严格依赖于继承关系
class OldboyPeople:
school = 'OldBoy'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def f1(self):
print(f'{self.name} say hello')
class Student(OldboyPeople):
def choose_course(self):
print('学生%s 正在选课' % self.name)
class Teacher(OldboyPeople):
# 老师的空对象,'egon',18,'male',3000,10
def __init__(self, name, age, sex, salary, level):
# 方式2:# 调用super()会得到一个特殊的对象,该对象会参照当前类的mro,去当前类的父类里找属性
super().__init__(name, age, sex) # 调用的是方法,自动传入对象
self.salary = salary
self.level = level
def score(self):
print('老师 %s 正在给学生打分' % self.name)
print(Teacher.mro()) # [<class '__main__.Teacher'>, <class '__main__.OldboyPeople'>, <class 'object'>]
5.补充知识
新式类:单凡是继承了
object
类的子类,以及该子类的子子孙孙类,都称之为:新式类
。经典类:没有继承
object
类的子类,以及该子类的子子孙孙类,都称之为:经典类
。在Python3中,不管这个类有没有继承类,都默认继承与
object
类。在Python2中,才有经典类,需要用新式类,只能手动继承。
Python的多继承
优点:
子类可以同时遗传多个父类的属性,最大限度地重用代码
缺点:
1.违背人的思维习惯:继承表达的是一种什么"是"什么的关系
2.代码可读性会变差
3.不建议使用多继承,有可能会引发可恶的菱形问题,扩展性变差,如果真的涉及到一个子类不可避免地要重用多个父类的属性,应该使用Mixins
6.菱形问题(多继承会到导致的问题)
菱形问题:一个子类继承的多条件分支 最终汇聚到了一个
非object
类,在菱形继承下大多数面向对象语言都不支持多继承,而在Python中,一个子类是可以同时继承多个父类的,这固然可以带来一个子类可以对多个不同父类加以重用的好处,但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题,有时候也被称为“死亡钻石”),菱形其实就是对下面这种继承结构的形象比喻。
class A(object):
def test(self):
print('from A')
pass
class B(A):
def test(self):
print('from B')
pass
class C(A):
def test(self):
print('from C')
pass
class D(C, B):
# def test(self):
# print('from D')
pass
# print(D.mro()) # 类D以及类D的对象访问属性都是参照该类的mro列表
# 输出:[<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
obj = D()
obj.test() # from C
print(D.test) # <function C.test at 0x039D84A8>
print(C.mro()) # 类C以及类C的对象访问属性都是参照该类的mro列表
# 输出:[<class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
c = C()
c.test() # from C
二:属性查找
可以通过对象.mro()
或者类名.mro()
来打印查找顺序,Python2中不行
1.新式类 与 经典类 关于属性查找的方式不同
新式类(Python3默认):广度优先,会在检索最后一条分支的时候检索大脑袋
经典类(Python2默认):深度优先,会在检索第一条分支的时候就直接一条道走到黑,即会检索大脑袋(共同的父类)
2.单继承背景下的属性查找
class Foo:
def f2(self):
print("Foo.f2")
def f1(self):
print('Foo.f1')
self.f2() # obj.f2()
class Bar(Foo):
def f2(self):
print("Bar.f2")
obj = Bar()
print(obj.f2)
# <bound method Bar.f2 of <__main__.Bar object at 0x0000023DFB4B5940>>
print(obj.f2())
# Bar.f2
print(obj.f1)
# <bound method Foo.f1 of <__main__.Bar object at 0x0000023DFB4B5940>>
print(obj.f1())
# Foo.f1
# Bar.f2
3.单继承背景下的隐藏属性查找
class Foo:
def __f2(self):
print("Foo.f2")
def f1(self):
print('Foo.f1')
self.__f2() # obj.f2()
class Bar(Foo):
def __f2(self):
print("Bar.f2")
obj = Bar()
print(obj.f1)
# <bound method Foo.f1 of <__main__.Bar object at 0x00000147E4A85940>>
print(obj.f1())
# Foo.f1
# Foo.f2
# None
4.菱形继承 与 非菱形继承 的 属性查找顺序
非菱形继承的查找顺序
都是一个分支一个分支地找下去,然后最后找object
class E:
# def test(self):
# print('from E')
pass
class F:
def test(self):
print('from F')
class B(E):
# def test(self):
# print('from B')
pass
class C(F):
# def test(self):
# print('from C')
pass
class D:
def test(self):
print('from D')
class A(B, C, D):
# def test(self):
# print('from A')
pass
# 新式类
# print(A.mro()) # A->B->E->C->F->D->object
obj = A()
obj.test() # 结果为:from F
菱形继承的属性查找
class G: # 在python2中,未继承object的类及其子类,都是经典类
# def test(self):
# print('from G')
pass
class E(G):
# def test(self):
# print('from E')
pass
class F(G):
def test(self):
print('from F')
class B(E):
# def test(self):
# print('from B')
pass
class C(F):
def test(self):
print('from C')
class D(G):
def test(self):
print('from D')
class A(B, C, D):
# def test(self):
# print('from A')
pass
# 新式类
# print(A.mro()) # A->B->E->C->F->D->G->object
# 经典类:A->B->E->G->C->F->D
obj = A()
obj.test() #
5.5.属性查找 - 进阶
class A:
def test(self):
super().test()
class B:
def test(self):
print('from B')
class C(A, B):
pass
print(A.mro()) # [<class '__main__.A'>, <class 'object'>]
print(B.mro()) # [<class '__main__.B'>, <class 'object'>]
print(C.mro()) # 在代码层面A并不是B的子类,但从MRO列表来看,属性查找时,就是按照顺序C->A->B->object,B就相当于A的“父类”
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]
obj = C()
obj.test() # 属性查找的发起者是类C的对象obj,所以中途发生的属性查找都是参照C.mro()
# from B
class A:
def test(self):
print('from A')
super().test1()
class B:
def test1(self):
print('from B')
class C(A, B):
def test1(self):
print('from C')
print(C.mro()) # 在代码层面A并不是B的子类,但从MRO列表来看,属性查找时,就是按照顺序C->A->B->object,B就相当于A的“父类”
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]
obj = C()
obj.test() # 属性查找的发起者是类C的对象obj,所以中途发生的属性查找都是参照C.mro()
6.总结
多继承到底要不用???
要用,但是规避几点问题
1.继承结构尽量不要过于复杂
2.推荐使用mixins机制:在多继承的背景下满足继承的什么"是"什么的关系
类相关的属性查找(类名.属性,该类的对象.属性),都是参照该类的mro
python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
三:Mixins机制
Mixins核心:在多继承背景下,尽可能地提升多继承的可读性
ps:让多继承满足人的思维习惯 ==> 什么 是 什么
class Vehicle: # 交通工具
def fly(self):
print("I am flying")
class CivilAircraft(Vehicle): # 民航飞机
pass
class Helicopter(Vehicle): # 直升飞机
pass
class Car(Vehicle): # 汽车并不会飞,但按照上述继承关系,汽车也能飞了
pass
按照上述的继承,汽车、民航飞机、直升机都是交通工具,如果把fly
这个功能写进交通工具中,汽车也会飞了,在当下,这不大现实
class Vehicle: # 交通工具
pass
class Flyable: # 新建一个类Flyable,只当做可飞行交通工具的父类
def fly(self):
print("I am flying")
class CivilAircraft(Vehicle, Flyable): # 民航飞机
pass
class Helicopter(Vehicle, Flyable): # 直升飞机
pass
class Car(Vehicle):
pass
所以再定义了一个Flyable
功能,让会飞的交通工具也去继承它
Python语言可没有接口功能,但是它可以多重继承。那Python是不是就该用多重继承来实现呢?是,也不是。说是,因为从语法上看,的确是通过多重继承实现的。说不是,因为它的继承依然遵守”is-a”关系,从含义上看依然遵循单继承的原则。
class Vehicle: # 交通工具
pass
class FlyableMixin: # 加一个Mixin结尾,可以当做一个假父类混入区中
def fly(self):
print("I am flying")
class CivilAircraft(Vehicle, FlyableMixin): # 民航飞机
pass
class Helicopter(Vehicle, FlyableMixin): # 直升飞机
pass
class Car(Vehicle): # 汽车并不会飞,但按照上述继承关系,汽车也能飞了
pass
这里可以看到,CivilAircraft和Helicopter都继承了Vehicle,还有FlyableMixin,但是FlyableMixin,表示混入(mix-in),它告诉别人,这个类是作为功能添加到子类中,而不是作为父类,它的作用同Java中的接口。
使用Mixin类实现多重继承要非常小心
1.首先它必须表示某一种功能,而不是某个物品,如同Java中的Runnable,Callable等
2.其次它必须责任单一,如果有多个功能,那就写多个Mixin类
3.然后,它不依赖于子类的实现
4.最后,子类即便没有继承这个Mixin类,也照样可以工作,就是缺少了某个功能。