一. 经典类和新式类
1.python多继承
在继承关系中,python子类自动用友父类中除了私有属性外的其他所有内容.python支持多继承.一个类可以拥有多个父类
2.python2和python3的区别
python2中存在两种类,一个叫经典类,在python2.2之前,一直使用的经典类.经典类是在基类的根如果什么都不写.表示继承xxx
另一个叫做心事类,在python2.2之后出现了心事类.新式类的特点是基类的根是object
python3中使用的都是新式类.如果基类谁都不继承,那这个类会默认继承object
二. 经典类的MRO
python早就为我们准备好了查看MRO的方法.可以使用类名.__mro__获取到累的MRO信息
1. 经典类的MRO 树型结构的深度优先遍历 --> 树形结构遍历
class Foo:
pass
class Foo(object):
pass
MRO: method resolution order 方法的查找顺序
class Base:
pass
class Base1:
def chi():
pass
class Bar(Base, Base1):
pass
b = Bar() # Bar -> Base -> Base1
b.chi()
再举一个例子
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
来看关系图
进行深度优先遍历
MRO: Foo-> H -> G -> F -> D -> B -> A -> C -> E.
2. 新式类的MRO C3算法
C3方法解决顺序
让我介绍几个简单的符号，这些符号对以下讨论很有用。我将使用快捷方式表示法
C1 C2 ... CN
表示类别列表[C1，C2，...，CN]。
列表的头部是它的第一个元素：
head = C1
而尾巴是列表的其余部分：
tail = C2 ... CN。
我也会用这个符号
C +（C1 C2 ... CN）= C C1 C2 ... CN
表示列表的总和[C] + [C1，C2，...，CN]。
现在我可以解释MRO如何在Python 2.3中运行。
考虑多继承层次结构中的C类，其中C继承自基类B1，B2，...，BN。我们想要计算C类的线性化L [C]。规则如下：
C的线性化是C的总和加上父母的线性化和父母的列表的合并。
用符号表示法：
L [C（B1 ... BN）] = C +合并（L [B1] ... L [BN]，B1 ... BN）
特别是，如果C是没有父项的对象类，则线性化是微不足道的：
L [object] =对象。
但是，通常必须根据以下处方计算合并：
取第一个列表的头部，即L [B1] [0]; 如果这个头不在任何其他列表的尾部，那么将它添加到C的线性化并将其从合并中的列表中删除，否则查看下一个列表的头部并将其取出，如果它是好头。然后重复操作，直到所有课程都被移除或者找不到好头。在这种情况下，不可能构造合并，Python 2.3将拒绝创建类C并将引发异常。
如果可以保留排序，则此处方确保合并操作保留排序。另一方面，如果无法保留订单（如上面讨论的严重订单不一致的例子），则无法计算合并。
如果C只有一个父（单继承），那么合并的计算是微不足道的。在这种情况下
L [C（B）] = C +合并（L [B]，B）= C + L [B]
官网解释 https://www.python.org/download/releases/2.3/mro/
举例说明
class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
class E(C, A):
pass
class F(D, E):
pass
class G(E):
pass
class H(G, F):
pass
首先确定的是要找的H
把每个类转换为C3算法的形式
L(A) = A
L(B) = B + L(A) + A
L(C) = C + L(A) + A
L(D) = D + L(B) + L(C) + BC
L(E) = E + L(C) + L(A) + CA
L(F) = F + L(D) + L(E) + DE
L(G) = G + L(E) + E
L(H) = H + L(G) + L(F) + GF
之后我们来化简
加法:merge(), 拿第一项的第一位和 后面每项的除了第一位比较. 如果没有出现, 则该位元素算出
如果出现了. 此时开始下一项的第一位继续和后面每一项的除了第一位比较:
L(A) = A
L(B) = B + L(A) + A = BC
L(C) = C + L(A) + A = CA
L(D) = D + L(B) + L(C) + BC = D + BC + CA = DBCA
L(E) = E + L(C) + L(A) + CA = E + CA + A + CA = ECA
L(F) = F + L(D) + L(E) + DE = F + DBCA + ECA = FDBECA
L(G) = G + L(E) + E = G +ECA + E = GECA
L(H) = H + L(G) + L(F) + GF = H + GECA + FDBECA + GF = HGFDBECA
三. super
super() 找MRO顺序的下一个,通常有两个使用的地方:
1.可以访问父类的构造方法
2.当子类方法想调用父类(MRO)中的方法
来看一道面试题
# MRO + super ⾯面试题
class Init(object):
def __init__(self, v):
print("init")
self.val = v
class Add2(Init):
def __init__(self, val):
print("Add2")
super(Add2, self).__init__(val)
print(self.val)
self.val += 2
class Mult(Init):
def __init__(self, val):
print("Mult")
super(Mult, self).__init__(val)
self.val *= 5
class HaHa(Init):
def __init__(self, val):
print("哈哈")
super(HaHa, self).__init__(val)
self.val /= 5
class Pro(Add2,Mult,HaHa): #
pass
class Incr(Pro):
def __init__(self, val):
super(Incr, self).__init__(val)
self.val+= 1
# Incr Pro Add2 Mult HaHa Init
p = Incr(5)
print(p.val)
c = Add2(2)
print(c.val)
先算出MRO
L(Init) = Init
L(Add2) =Add2 + L(Init) + Init = Add2 , Init
L(Mult) = Mult + L(Init) + Init = Mult ,Init
L(HaHa) = HaHa + L(Init) + Init = HaHa,Init
L(Pro) = Pro +L(Add2) + L(Mult) + L(HaHa) + Add2,Mult,HaHa = Pro + Add2 , Init + Mult ,Init + HaHa,Init + Add2,Mult,HaHa = Pro,Add2,Mult,HaHa,Init
再进行运算
