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)