python的MRO和C3算法

python2類和python3類的區別
pyhon2中才分新式類與經典類,python3中統一都是新式類
Python 2.x中默認都是經典類,只有顯式繼承了object纔是新式類
python 3.x中默認都是新式類,經典類被移除,沒必要顯式的繼承object
改變了經典類中一個多繼承的bug,由於其採用了廣度優先的算法

 1 class A(object):
 2     def test(self):
 3         print('from A')
 4 
 5 class B(A):
 6     def test(self):
 7         print('from B')
 8 
 9 class C(A):
10     def test(self):
11         print('from C')
12 
13 class D(B):
14     def test(self):
15         print('from D')
16 
17 class E(C):
18     def test(self):
19         print('from E')
20 
21 class F(D,E):
22     # def test(self):
23     #     print('from F')
24     pass
25 f1=F()
26 f1.test()
27 print(F.__mro__) #只有新式纔有這個屬性能夠查看線性列表,經典類沒有這個屬性
28 #新式類繼承順序:F->D->B->E->C->A
29 #經典類繼承順序:F->D->B->A->E->C

MRO: method resolution order 方法的查找順序
經典類的MRO 樹形結構的深度優先遍歷 --> 樹形結構遍歷

 

 1 class A:
 2     pass
 3 class B(A):
 4     pass
 5 class C(A):
 6     pass
 7 class D(B, C):
 8     pass
 9 class E:
10     pass
11 class F(D, E):
12     pass
13 class G(F, D):
14     pass
15 class I:
16     pass
17 class J(B, C):
18     pass
19 class K(A):
20     pass
21 class H(I, J, K):
22     pass
23 class Foo(H, G):
24     pass
25 print(Foo.__mro__)
26 結果
27 Foo -->H-->I-->J-->G-->F-->D-->B-->C-->K-->A-->E-->'object'

新式類的MRO C3算法
1. 拆分
2. 合併

 1 class A:
 2     pass
 3 class B(A):
 4     pass
 5 class C(A):
 6     pass
 7 class D(B, C):
 8     pass
 9 class E(C, A):
10     pass
11 class F(D, E):
12     pass
13 class M:
14     pass
15 class N(M):
16     pass
17 class P(E, A):
18     pass
19 class X:
20     pass
21 class Q(P,N,X):
22     pass
23 class G(Q, F):
24     pass
25 class H(G, F):
26     pass
27 
28 
29 加法:merge(),拿第一項的第一位和後面項除了第一位的每位比較,若是沒有出現,則該位元素算出
30 若是出現了,此時開始下一項的第一位繼續和後面項除了第一位的每一位比較,
31 若是後邊項裏除了第一位的其餘位出現有,則繼續開始拿下一項的第一位和後一項除了第一位的其餘位作比較
32 若是後邊項沒有出現,取完這一項的第一位後,從新返回第一項繼續執行判斷第一項的第一位與後邊項除了第一位比較
33 
34 好比
35 F + DBCA + ECA + DE
36 DBCA + ECA + DE
37 BCA + ECA + E
38 CA + CA
39 A + A
40 
41 思路:
42 第一次拿第一項的第一位F與DBCA,ECA,DE比較,這三個數除了第一位後面的每一項都沒有F出現,
43 因此把全部的F消除,取值F
44 第二次拿第二項DBCA的第一位D與ECA,DE比較,這兩數中除了第一位後邊的每一項都沒有D出現,
45 因此就把全部的D消除,而後取值D
46 第三次拿第二項BCA的B與ECA,E比較,這兩個數中除了第一位後邊的每一項都沒有B出現,
47 因此就把全部的B消除,取值B
48 第四次拿第二項CA的C與ECA,E比較,ECA出現了C,因此不動CA,而後拿下一項的ECA的第一位E與最後一項的值E作比較,
49 由於ECA的E重複了最後一項E,因此也不動ECA,而後拿最後一項的E與後邊做比較,由於後邊沒項值,
50 因此消除全部的E,取值E
51 第四次拿返回開頭拿第二項CA中的C與後邊的項CA作比較,由於後邊項中除了第一位,其餘位沒有C,
52 因此消除全部的C,取值C
53 第五次拿第二項的A與後邊的項A作比較,由於後邊項值有A,全部拿後邊項A與後邊項作比較,由於後邊項沒有值,
54 因此消除全部的A,取值A
55 結果
56 FDBECA
57 
58 
59 求H的MRO
60 設求MRO的算法是L
61 解析步驟:
62                                     拆分                          合併      
63 L(H) = H + L(G) + L(F) + GF #H + GQPFDBECANMX + FDBECA + GF = HGQPFDBECANMX
64 L(G) = G + L(Q) + L(F) + QF #G + QPECANMX + FDBECA + QF = GQPFDBECANMX
65 L(Q) = Q + L(P) + L(N) + L(X) + PNX #Q + PECA + NM + X + PNX = QPECANMX
66 L(X) = X    #X
67 L(P) = P + L(E) + L(A) + EA #P + ECA + A + EA = PECA
68 L(N) = N + L(M) + M     #N + M + M = NM
69 L(M) = M    #M
70 L(F) = F + L(D) + L(E) + DE #F + DBCA + ECA + DE = FDBECA
71 L(E) = E + L(C) + L(A) + CA #E + CA + A + CA = ECA
72 L(D) = D + L(B) + L(C) + BC #D + BA + CA + BC = DBCA
73 L(C) = C + L(A) + A     #C + A + A = CA
74 L(B) = B + L(A) + A     #B + A + A = BA
75 L(A) = A    #A
76 因此結果是
77 HGQPFDBECANMX
78 
79 和電腦運算的結果一致
80 print(H.__mro__)

super() 找MRO順序的下一個

 1 class Base1:
 2     def chi(self):
 3         print("我是Base1")
 4 
 5 class Base2:
 6     def chi(self):
 7         print("我是Base2")
 8 
 9 class Base3:
10     def chi(self):
11         print("我是Base3")
12 
13 class Bar(Base1, Base2, Base3):
14     def chi(self):
15         print("我是Bar裏面的chi1")
16         # super(類名, self)  從某個類開始找下一個MRO
17         super(Base2, self).chi()    # 此時調用的super. 在Bar調用 -> super表示找MRO裏的下一個
18         # super().chi() # super(Bar, self).chi()
19         print("我是Bar裏面的chi2")
20 
21 b = Bar()   # Bar, Base1, Base2, Base3, object
22 b.chi()
23 print(Bar.__mro__)
24 
25 結果:
26 我是Bar裏面的chi1
27 我是Base3
28 我是Bar裏面的chi2
29 (<class '__main__.Bar'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class '__main__.Base3'>, <class 'object'>)
30 
31 
32 事例2
33 class Base1:
34     def chi(self):
35         super().chi()
36         print("我是Base1")
37 
38 class Base2:
39     def chi(self):
40         super().chi()
41         print("我是Base2")
42 
43 class Base3:
44     def chi(self):
45         print("我是Base3")
46 
47 class Bar(Base1, Base2, Base3):
48     def chi(self):
49         print("我是Bar裏面的吃1")
50         super(Bar, self).chi()
51         print("我是Bar裏面的吃2")
52 
53 b = Bar()
54 b.chi()
55 
56 結果
57 我是Bar裏面的吃1
58 我是Base3
59 我是Base2
60 我是Base1
61 我是Bar裏面的吃2

MRO + super 面試題

 1 class Init(object):
 2     def __init__(self, v):
 3         print("init")
 4         self.val = v
 5 
 6 class Add2(Init):
 7     def __init__(self, val):
 8         print("Add2")
 9         super(Add2, self).__init__(val)
10         print(self.val)
11         self.val += 2
12 
13 class Mult(Init):
14     def __init__(self, val):
15         print("Mult")
16         super(Mult, self).__init__(val)
17         self.val *= 5
18 
19 class HaHa(Init):
20     def __init__(self, val):
21         print("哈哈")
22         super(HaHa, self).__init__(val)
23         self.val /= 5
24 
25 class Pro(Add2,Mult,HaHa):
26     pass
27 
28 class Incr(Pro):    # incr->pro->add2->Mult->HaHa->init
29     def __init__(self, val):
30         super(Incr, self).__init__(val)
31         self.val += 1
32 p = Incr(5)
33 print(p.val)