MRR计算 python

python2类和python3类的区别
pyhon2中才分新式类与经典类,python3中统一都是新式类
Python 2.x中默认都是经典类,只有显式继承了object才是新式类
python 3.x中默认都是新式类,经典类被移除,不必显式的继承object
改变了经典类中一个多继承的bug,因为其采用了广度优先的算法

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C

MRO: method resolution order 方法的查找顺序
经典类的MRO 树形结构的深度优先遍历 --> 树形结构遍历

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 I:
    pass
class J(B, C):
    pass
class K(A):
    pass
class H(I, J, K):
    pass
class Foo(H, G):
    pass
print(Foo.__mro__)
结果
Foo -->H-->I-->J-->G-->F-->D-->B-->C-->K-->A-->E-->'object'

新式类的MRO C3算法
1. 拆分
2. 合并

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 M:
    pass
class N(M):
    pass
class P(E, A):
    pass
class X:
    pass
class Q(P,N,X):
    pass
class G(Q, F):
    pass
class H(G, F):
    pass


加法:merge(),拿第一项的第一位和后面项除了第一位的每位比较,如果没有出现,则该位元素算出
如果出现了,此时开始下一项的第一位继续和后面项除了第一位的每一位比较,
如果后边项里除了第一位的其他位出现有,则继续开始拿下一项的第一位和后一项除了第一位的其他位做比较
如果后边项没有出现,取完这一项的第一位后,重新返回第一项继续执行判断第一项的第一位与后边项除了第一位比较

比如
F + DBCA + ECA + DE
DBCA + ECA + DE
BCA + ECA + E
CA + CA
A + A

思路:
第一次拿第一项的第一位F与DBCA,ECA,DE比较,这三个数除了第一位后面的每一项都没有F出现,
所以把所有的F消除,取值F
第二次拿第二项DBCA的第一位D与ECA,DE比较,这两数中除了第一位后边的每一项都没有D出现,
所以就把所有的D消除,然后取值D
第三次拿第二项BCA的B与ECA,E比较,这两个数中除了第一位后边的每一项都没有B出现,
所以就把所有的B消除,取值B
第四次拿第二项CA的C与ECA,E比较,ECA出现了C,所以不动CA,然后拿下一项的ECA的第一位E与最后一项的值E做比较,
因为ECA的E重复了最后一项E,所以也不动ECA,然后拿最后一项的E与后边作比较,因为后边没项值,
所以消除所有的E,取值E
第四次拿返回开头拿第二项CA中的C与后边的项CA做比较,因为后边项中除了第一位,其他位没有C,
所以消除所有的C,取值C
第五次拿第二项的A与后边的项A做比较,因为后边项值有A,所有拿后边项A与后边项做比较,因为后边项没有值,
所以消除所有的A,取值A
结果
FDBECA


求H的MRO
设求MRO的算法是L
解析步骤:
                                    拆分                          合并      
L(H) = H + L(G) + L(F) + GF #H + GQPFDBECANMX + FDBECA + GF = HGQPFDBECANMX
L(G) = G + L(Q) + L(F) + QF #G + QPECANMX + FDBECA + QF = GQPFDBECANMX
L(Q) = Q + L(P) + L(N) + L(X) + PNX #Q + PECA + NM + X + PNX = QPECANMX
L(X) = X    #X
L(P) = P + L(E) + L(A) + EA #P + ECA + A + EA = PECA
L(N) = N + L(M) + M     #N + M + M = NM
L(M) = M    #M
L(F) = F + L(D) + L(E) + DE #F + DBCA + ECA + DE = FDBECA
L(E) = E + L(C) + L(A) + CA #E + CA + A + CA = ECA
L(D) = D + L(B) + L(C) + BC #D + BA + CA + BC = DBCA
L(C) = C + L(A) + A     #C + A + A = CA
L(B) = B + L(A) + A     #B + A + A = BA
L(A) = A    #A
所以结果是
HGQPFDBECANMX

和电脑运算的结果一致
print(H.__mro__)

super() 找MRO顺序的下一个

class Base1:
    def chi(self):
        print("我是Base1")

class Base2:
    def chi(self):
        print("我是Base2")

class Base3:
    def chi(self):
        print("我是Base3")

class Bar(Base1, Base2, Base3):
    def chi(self):
        print("我是Bar里面的chi1")
        # super(类名, self)  从某个类开始找下一个MRO
        super(Base2, self).chi()    # 此时调用的super. 在Bar调用 -> super表示找MRO里的下一个
        # super().chi() # super(Bar, self).chi()
        print("我是Bar里面的chi2")

b = Bar()   # Bar, Base1, Base2, Base3, object
b.chi()
print(Bar.__mro__)

结果:
我是Bar里面的chi1
我是Base3
我是Bar里面的chi2
(<class '__main__.Bar'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class '__main__.Base3'>, <class 'object'>)


事例2
class Base1:
    def chi(self):
        super().chi()
        print("我是Base1")

class Base2:
    def chi(self):
        super().chi()
        print("我是Base2")

class Base3:
    def chi(self):
        print("我是Base3")

class Bar(Base1, Base2, Base3):
    def chi(self):
        print("我是Bar里面的吃1")
        super(Bar, self).chi()
        print("我是Bar里面的吃2")

b = Bar()
b.chi()

结果
我是Bar里面的吃1
我是Base3
我是Base2
我是Base1
我是Bar里面的吃2

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):    # incr->pro->add2->Mult->HaHa->init
    def __init__(self, val):
        super(Incr, self).__init__(val)
        self.val += 1
p = Incr(5)
print(p.val)