这是一个扩展到这个问题 ，并提出了一个问题，你，我的同胞StackOverflowers，将希望能够帮助我。 从引用的问题，考虑到最终的代码示例：
class A(object):
def __init__(self):
print "entering A"
print "leaving A"
class B(object):
def __init__(self):
print "entering B"
super(B, self).__init__()
print "leaving B"
class C(A,B):
def __init__(self):
print "entering c"
super(C, self).__init__()
print "leaving c"
正如海报指出，初始化C使用时，将__init__对于B不会被调用。 在考虑雷蒙德赫廷杰的帖子 ，该代码class A应修改也叫super().__init__()
class A(object):
def __init__(self):
print "entering A"
super(A, self).__init__()
print "leaving A"
我们都好为止。 然而，如果我们班__init__函数接受参数？ 让我们假设所有的__init__函数接受一个参数和一致性，我们将简单地称之为foo ，代码是现在：
class A(object):
def __init__(self, foo):
print "entering A"
super(A, self).__init__(foo)
print "leaving A"
class B(object):
def __init__(self, foo):
print "entering B"
super(B, self).__init__(foo)
print "leaving B"
class C(A,B):
def __init__(self, foo):
print "entering c"
super(C, self).__init__(foo)
print "leaving c"
在这里，我们遇到了障碍。 当初始化任何类A的，B或C，我们最终调用object.__init__带一个参数， foo ，其与错误TypeError: object.__init__() takes no parameters 。 然而，去除的一个super().__init__的功能就意味着类不再在多重继承的情况下合作。
毕竟，我的问题是，一个人如何解决这个问题？ 看来，多重继承是什么，但在没有参数传递给案件破__init__功能。
更新：
罗布的意见建议剥离关键字参数（在雷蒙德H公司的岗位参考）。 这实际上非常适用于多重继承的情况下，直到你改变你的代码。 如果你的函数一个不再使用的关键字参数之一，并停止剥离，而不修改调用函数，你仍然会收到类型错误上面提到的。 因此，这似乎是为大型项目脆弱的解决方案。
诚然，这种解决方案可能不是最Python的或理想的，但创建对象的包装类，像这样可以让你绕过每个参数__init__在继承：
class Object(object):
def __init__(self,*args,**kwargs):
super(Object,self).__init__()
class A(Object):
def __init__(self,*args,**kwargs):
super(A,self).__init__(*args,**kwargs)
class B(Object):
def __init__(self,*args,**kwargs):
super(B,self).__init__(*args,**kwargs)
class C(A,B):
def __init__(self,*args,**kwargs):
super(C,self).__init__(*args,**kwargs)
我的回答可能有点过。 我一直在寻找的代码来解决我的具体问题。 但搜索小时后我找不到很好的例子。 所以我写了这个小测试代码。 我认为这绝对是合作的多重继承的例子。 我真的觉得有人可能会觉得它有用。 所以在这里，我们走！
基本上，我有一个相当大的班，我想进一步分裂，但由于我的特殊情况下，它必须是同一类。 另外我所有的子类有自己inits，我想基础初始化后，执行这么说。
测试代码
"""
Testing MRO Functionality of python 2.6 (2.7)
"""
class Base(object):
def __init__(self, base_arg, **kwargs):
print "Base Init with arg: ", str(base_arg)
super(Base, self).__init__()
def base_method1(self):
print "Base Method 1"
def base_method2(self):
print "Base Method 2"
class ChildA(Base):
def __init__(self, child_a_arg, **kwargs):
super(ChildA, self).__init__(**kwargs)
print "Child A init with arg: ", str(child_a_arg)
def base_method1(self):
print "Base Method 1 overwritten by Child A"
class ChildB(Base):
def __init__(self, child_b_arg, **kwargs):
super(ChildB, self).__init__(**kwargs)
print "Child B init with arg: ", str(child_b_arg)
def base_method2(self):
print "Base Method 2 overwritten by Child B"
class ChildC(Base):
def __init__(self, child_c_arg, **kwargs):
super(ChildC, self).__init__(**kwargs)
print "Child C init with arg: ", str(child_c_arg)
def base_method2(self):
print "Base Method 2 overwritten by Child C"
class Composite(ChildA, ChildB, ChildC):
def __init__(self):
super(Composite, self).__init__(base_arg=1, child_a_arg=2, child_b_arg=3, child_c_arg=4)
print "Congrats! Init is complete!"
if __name__ == '__main__':
print "MRO: ", str(Composite.__mro__), "\n"
print "*** Init Test ***"
test = Composite()
print "*** Base Method 1 Test ***"
test.base_method1()
print "*** Base Method 2 Test ***"
test.base_method2()
产量
MRO: (<class '__main__.Composite'>,
<class '__main__.ChildA'>,
<class '__main__.ChildB'>,
<class '__main__.ChildC'>,
<class '__main__.Base'>,
<type 'object'>)
*** Init Test ***
Base Init with arg: 1
Child C init with arg: 4
Child B init with arg: 3
Child A init with arg: 2
Congrats! Init is complete!
*** Base Method 1 Test ***
Base Method 1 overwritten by Child A
*** Base Method 2 Test ***
Base Method 2 overwritten by Child B
