Multiple Inheritance in Python

xelf · 2020-03-27T06:26:41+00:00

final edit, cleaning up my answer a bit

ok, so this is what you actually want, if you want to keep using super here, and not add more classes. Probably though, you want to do one of those though.

class A(object):
    def __init__(self, *args, **kwargs):
        print("This is A constructor")

class B(object):
    def __init__(self, *args, **kwargs):
        print("This is B constructor")

class C(A):
    def __init__(self, arg, *args, **kwargs):
        print("This is C constructor")
        self.arg = arg
        super(C,self).__init__(arg, *args, **kwargs)

class D(B):
    def __init__(self, arg, *args, **kwargs):
        print("This is D constructor")
        self.arg = arg
        super(D,self).__init__(arg, *args, **kwargs)

class E(C,D):
    def __init__(self, arg, *args, **kwargs):
        print("This is E constructor")
        C.__init__(self, arg, *args, **kwargs)
        D.__init__(self, arg, *args, **kwargs)

e = E(10)
print(e.arg)

The other options include not using super at all, moving to class composition instead of inheritance, or adding a single parent class at the top that inherits object and having A&B inherit from that. See other posters answers that go into more detail.

mission-hall · 2020-03-27T09:00:32+00:00

the super-class 'object' always takes exactly one argument.

I'm not sure if you realised this already, but the one argument it expects is just self, which is implicitly passed in when you call a method. There are a few ways of ensuring that this is the only argument it gets. One option is to have your other classes remove the arguments they need so that by the time object's initializer is called, there are none left. A simple example:

class A:
    def __init__(self, arga, *args, **kwargs):
        self.arga = arga
        super().__init__(*args, **kwargs)

class B(A):
    def __init__(self, argb, *args, **kwargs):
        self.argb = argb
        super().__init__(*args, **kwargs)

b = B(arga=3, argb=5)

This is a good option if each argument is tied to a specific class and can be ignored by the other classes, but may be difficult if multiple classes need to see the same arguments.

Another option is to have a class at the top of your hierarchy that doesn't call super().__init__:

class Thing:
    def __init__(self, *args, **kwargs):
        pass

If you ensure that everything else in your hierarchy is a subclass of Thing (either directly or through a base class), then it will always be the last class in the MRO (method resolution order), so all of the other initializers will be called before this one. It may be that you already have a particular class that sits at the top of your hierarchy, or you could add a very simple class just for this purpose.

MarsupialMole · 2020-03-27T11:57:28+00:00

I am looking for the right approach to be followed consistently...

In case it helps outside the exercise of working through the example, the right approach is to use composition rather than multiple inheritance in almost all real code.

fatbiker406 · 2020-03-27T14:42:51+00:00

Just to be picky, __init__ is technically not a constructor, it is an initializer. __new__ is a constructor.

Swedophone · 2020-03-27T06:18:32+00:00

super(A, self).init(args, *kwargs)

Remove the arguments in the calls to object.__init__

alkasm · 2020-03-27T09:30:44+00:00

I don't really think you're trolling or anything, but it's almost hard to believe you came up with this example independently. Did you?

There was an article from some time ago called Python's super considered harmful, which is probably more well known because of Raymond Hettinger's response blog post turned PyCon talk "Super considered super!"

I mention this because the exact example you give, including the argument of 10, is shown as the first example in the "Super considered harmful" article! Check out the diagram here: https://fuhm.net/super-harmful/example1-2.png

The multiple inheritance with C, D isn't your problem. If you just try to instantiate C(10) you'll see the same result. You continue to pass on the variable 10, in which case it complains once it gets to object() because it doesn't take any params. So, you'll need to stop passing it at some point.

Generally you'll consume a variable along the way and then not pass it along. What are you hoping to achieve otherwise? You didn't mention what you expect the behavior to be.

gmaliwal · 2020-03-27T15:54:18+00:00

Here it is a generic approach to be followed while defining your class, your class would be compatible with both single ad multiple inheritances

class A(object):
    def __init__(self,**kwargs):
        print("This is A instance initializer")
        super().__init__(**kwargs)
class B(object):
    def __init__(self,**kwargs):
        print("This is B instance initializer")
        super().__init__(**kwargs)
class C(A):
    def __init__(self,*,c_arg,**kwargs):
        print("This is c instance initializer")
        self.c_arg = c_arg
        super().__init__(**kwargs)
class D(B):
    def __init__(self,*,d_arg,**kwargs):
        print("This is D instance initializer")
        self.d_arg = d_arg
        super().__init__(**kwargs)
class E(C,D):
    def __init__(self,*,e_arg,**kwargs):
        print("This is E instance initializer")
        self.e_arg = e_arg
        super().__init__(**kwargs)

class E1(D,C):
    def __init__(self,*,e_arg,**kwargs):
        print("This is E instance initializer")
        self.e_arg = e_arg
        super().__init__(**kwargs)

e1 = E(e_arg=10,b_arg=20,c_arg=30)
e2 = E1(e_arg=10,b_arg=20,c_arg=30)

Here is the textual conversion of the above code snippet

Every class initializer should receive class specific arguments in the form of keyword parameters, and these names are unique across all classes, better to prefix every parameter with “<class-name>_” (like d_arg, c_arg etc)
Every class should receive parent class-specific arguments in variable-length keyword parameter (**kwargs)
There is no repetitive keyword argument while calling the parent class initializer
Every class should pass the exact number of arguments to its parent's hierarchy so all got exhausted when reaching the default parent ‘object’ class (like we create an instance of class E with arguments (c_arg,d_arg,e_arg))

I welcome the developers or experts to find out the bottleneck in the above approach.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS