Multiple Inheritance using super()

[Sagar]

Hi All,
I was trying to understand Inheritance concept in Python.
When I wrote the code without using super(), I was getting desired results. You can see that below

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

class Base1(object):     def __init__(self):         self.name1 = "Peter"       def showName1(self):         print(self.name1)   class Base2(object):     def __init__(self):         self.name2 = "John"       def showName2(self):         print(self.name2)   class Child(Base2, Base1):     def __init__(self):         self.name3 = "Sagar"         Base1.__init__(self)         Base2.__init__(self)                 def showName3(self):         print(self.name3)   obj = Child() obj.showName1() obj.showName2() obj.showName3()

Output:
Peter
John
Sagar

But when I wrote super() in place of writing class name in Child class's __init__() function,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

class Base1(object):     def __init__(self):         self.name1 = "Peter"       def showName1(self):         print(self.name1)   class Base2(object):     def __init__(self):         self.name2 = "John"       def showName2(self):         print(self.name2)   class Child(Base2, Base1):     def __init__(self):         self.name3 = "Sagar"         super(Child,self).__init__()                 def showName3(self):         print(self.name3)   obj = Child() obj.showName1() obj.showName2() obj.showName3()

I am getting following error:

Error:
Traceback (most recent call last):
  File "D:\Sagar\Python Related\Scripts\MultipleInheritance.py", line 25, in <module>
    obj.showName1()
  File "D:\Sagar\Python Related\Scripts\MultipleInheritance.py", line 6, in showName1
    print(self.name1)
AttributeError: 'Child' object has no attribute 'name1'

Is super() not used in case of Multiple Inheritance ?

[Mekire]

Is super() not used in case of Multiple Inheritance ?

I think the issue is all classes in the chain need to make the call to super, even if you think they are the last call.

Hide/Show

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

class Base1(object):     def __init__(self):         self.name1 = "Peter"         super(Base1, self).__init__()        def showName1(self):         print(self.name1)      class Base2(object):     def __init__(self):         self.name2 = "John"         super(Base2, self).__init__()        def showName2(self):         print(self.name2)     class Child(Base2, Base1):     def __init__(self):         self.name3 = "Sagar"         super(Child, self).__init__()                def showName3(self):         print(self.name3)     obj = Child() obj.showName1() obj.showName2() obj.showName3()

You should probably watch this video if you have not done so:  
Super considered super

[Sagar]

I was studying super() and its calling sequence of the Base and Sibling classes. I found that super is called in anticlockwise order and stops calling the next sibling or parent if there's no super() found in current class. I am sharing, what I found. Please correct me, if I am wrong.
Consider the following code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class A(object):     def foo(self):         print('A')   class B(A):     def foo(self):         print('B')         super().foo()    class C(A):     def foo(self):         print('C')         super().foo()    class D(B,C):     def foo(self):         print('D')         super().foo()    d = D() d.foo()

Here D inherits from the classes B and C and class A is the Base class of both classes B and C.
The output given by the above code is as follows:

Output:
D
B
C
A

Now I included another class called "Foreign" in between and without super() like this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class A(object):     def foo(self):         print('A')   class Foreign(object):     def foo(self):         print('Foreign')         #super().foo()   class B(Foreign):     def foo(self):         print('B')         super().foo()    class C(A):     def foo(self):         print('C')         super().foo()    class D(B,C):     def foo(self):         print('D')         super().foo()    d = D() d.foo()

and the output for the above was:

Output:
D
B
Foreign

Once I un-commented the super() of Foreign Class, the output was like this:

Output:
D
B
Foreign
C
A

If I change the order of Base classes in the class definition of class D that is:
from

1	class D(B,C):

to

1	class D(C,B):

the order of calling super() also changes.
Note: There is no super in class A.