多重继承 <python>

一入深坑深思海，苦心专愁，愁更愁！！！
不惜一切代价地避免多重继承，它带来的麻烦比能解决的问题都多。
如果你非要用，那你得准备好专研类的层次结构，以及花时间去找各种东西的来龙去脉吧

可以试试组合,组合则是利用模块和别的类中的函数调用实现了相同的目的

经典类中MRO搜索采用简单的从左到右的深度优先顺序
super()可以保证菱形顶部的公共基类的init()方法只会运行一次
新式类是广度优先

# 8-1
'''去除A 则self.value将不存在'''
class A(object):
    def __init__(self,value):
        self.value=value
        print("A --> {}".format(self.value))
        
class B(object):
    def __init__(self):
        self.value*=10
        print("B --> {}".format(self.value))
        
class C(object):
    def __init__(self):
        self.value+=100
        print("C --> {}".format(self.value))
        
class D(A,B,C):
    def __init__(self,value):
        A.__init__(self,value)
        B.__init__(self)
        C.__init__(self)
        print("D --> {}".format(self.value))
        
'''多重继承的顺序的实例'''    
class E(A,B,C):
    def __init__(self,value):
        A.__init__(self,value)
        C.__init__(self)
        B.__init__(self)
        print("E --> {}".format(self.value))
        
class F(A,C,B):
    def __init__(self,value):
        A.__init__(self,value)
        B.__init__(self)
        C.__init__(self)
        print("F --> {}".format(self.value))
        
d=D(1)
e=E(1)
f=F(1)

from pprint import pprint
pprint(D.mro())
pprint(F.mro())

A --> 1
B --> 10
C --> 110
D --> 110
A --> 1
C --> 101
B --> 1010
E --> 1010
A --> 1
B --> 10
C --> 110
F --> 110
[,
 ,
 ,
 ,
 ]
[,
 ,
 ,
 ,
 ]

# 8-2
'''
使用旧版继承，基础类A.__init__ 会调用多次
A --> 1
H --> 11
A --> 1
G --> 4
J --> 4
JHGA：先左后右，H-G

注掉G.init
A --> 1
H --> 11
J --> 11
JHGA：左右

再改H.init--->super()
A --> 1
G --> 4
H --> 14
J --> 14
JHGA：深度优先即G执行，H为super()也可执行

注掉H.init
A --> 1
G --> 4
J --> 4
JHGA：左右

再改G.init--->super()
A --> 1
G --> 4
J --> 4
JHGA：深度优先G执行，H没有init
注意关键的地方来了，所有的初始化方法会按照跟那些__init__()相反的顺序来运行
'''
class A(object):
    def __init__(self,value):
        self.value=value
        print("A --> {}".format(self.value))
        
class G(A):
    def __init__(self,value):
#         A.__init__(self,value)
        super(G,self).__init__(value)
        self.value*=4
        print("G --> {}".format(self.value))
        
class H(A):
    def __init__(self,value):
        A.__init__(self,value)
#         super(H,self).__init__(value)
        self.value+=10
        print("H --> {}".format(self.value))
        
class J(H,G):
    def __init__(self,value):
#         H.__init__(self,value)
        G.__init__(self,value)
        print("J --> {}".format(self.value))
        
j=J(1)
from pprint import pprint
pprint(J.mro())

A --> 1
G --> 4
J --> 4
[,
 ,
 ,
 ,
 ]

# 8-3
'''
全super()只执行一次
A --> 1
G --> 4
H --> 14
I --> 14

G.super(),H.init
A --> 1
H --> 11
I --> 11
IHGA:有init,左开始，H执行。G时因super,A不再执行

G.init,H.super()
A --> 1
G --> 4
H --> 14
I --> 14
IHGA:执行广度优先
'''
class A(object):
    def __init__(self,value):
        self.value=value
        print("A --> {}".format(self.value))
        
class G(A):
    def __init__(self,value):
        super(G,self).__init__(value)
#         A.__init__(self,value)
        self.value*=4
        print("G --> {}".format(self.value))
        
class H(A):
    def __init__(self,value):
#         super(H,self).__init__(value)
        A.__init__(self,value)
        self.value+=10
        print("H --> {}".format(self.value))
        
class I(H,G):
    def __init__(self,value):
        super(I,self).__init__(value)
        print("I --> {}".format(self.value))
        
i=I(1)
from pprint import pprint
pprint(I.mro())

A --> 1
H --> 11
I --> 11
[,
 ,
 ,
 ,
 ]

多重继承

你可能感兴趣的:(多重继承 )