super() and order of running method in class inheritance

[akbarza]

hi in code:

'''
from:https://stackoverflow.com/questions/64740117/how-method-resolution-order-mro-is-working-in-this-python-code
title of the above page: How Method Resolution Order (MRO) is working in this Python code
'''

class parent:
    def __init__(self):
        self.a=2
        self.b=4
    def form1(self): 
        print("calling parent from1")
        print('p',self.a+self.b)
 
class child1(parent):
    def __init__(self):
        self.a=50
        self.b=4
    def form1(self):
        print('bye',self.a-self.b)
    def callchildform1(self):
        print("calling parent from child1")
        super().form1()
 
class child2(parent):
    def __init__(self):
        self.a=3
        self.b=4
    def form1(self):
        print('hi',self.a*self.b)
    def callchildform1(self):
        print("calling parent from child2")
        super().form1()
 
class grandchild(child1,child2):
    def __init__(self):
        self.a=10
        self.b=4
    def callingparent(self):
        super().form1()
        
print(f" grandchild.__mro__ is {grandchild.__mro__}")
g=grandchild()
g.callchildform1()
print(f"child1.__mro__ is {child1.__mro__}")

the output is:

Output:
 grandchild.__mro__ is (<class '__main__.grandchild'>, <class '__main__.child1'>, <class '__main__.child2'>, <class '__main__.parent'>, <class 'object'>)
calling parent from child1
hi 40
child1.__mro__ is (<class '__main__.child1'>, <class '__main__.parent'>, <class 'object'>)

according to MRO of the class grandchild, the line g.callchildform1() causes to callchildform1's method in classchild1 class is called and in this method there is super().form1() (line 22).
now we are in the class child1 and for the mro of this class, the form1 method of parent class must be called. but the form1 method of class child2 is called.
explain to me why Python acts as this.
As in the docstring of this code has been written, this subject has been discussed in the given address, but the issue is ambiguous to me still.
thanks

[Gribouillis]

explain to me why Python acts as this.

This is explained in the documentation of super

The search starts from the class right after the type.

For example, if __mro__ of object_or_type is D -> B -> C -> A -> object and the value of type is B, then super() searches C -> A -> object.

In your case, the __mro__ of g is grandchild -> child1 -> child2 -> parent -> object So in child1, super() finds child2 before parent.

[deanhystad]

As in the docstring of this code has been written, this subject has been discussed in the given address, but the issue is ambiguous to me still.

What part confuses you? Maybe an example with more depth will help?
class A:
pass

class B:
pass

class C:
pass

class D:
pass

class E(A, B):
pass

class F(C, D):
pass

class G(E, F):
pass

print(*G.__mro__, sep="\n")

Output:
<class '__main__.G'>
<class '__main__.E'>
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.F'>
<class '__main__.C'>
<class '__main__.D'>
<class 'object'>

Which we can draw like this:

Output:
A  B  C  D
\ /   \ /
 E     F
  \   /
    G

We traverse the mro graph giving preference the left node (first superclass). If we don't find what we need in the left branch, back up one level and try the next superclass. So if we cannot find the method we are looking for in A, back up to E and try the next superclass of E which is B. If we can't find it there we have to back up to G and check the next superclass, F. The search order is Look local, then look at leftmost super. When you reach object, back up and look at next super.

In practice, using inheritance like this will quickly drive you insane, and multiple inheritance examples in Python are rare compared to single inheritance. But the mechanism is in place for you to drive yourself insane if that's what you want to do.

[akbarza]

explain to me why Python acts as this.

This is explained in the documentation of super

The search starts from the class right after the type.

For example, if __mro__ of object_or_type is D -> B -> C -> A -> object and the value of type is B, then super() searches C -> A -> object.

In your case, the __mro__ of g is grandchild -> child1 -> child2 -> parent -> object So in child1, super() finds child2 before parent.

hi, thanks for the reply
I think I read the segment of document about super() at least five

[akbarza]

hi
thanks for all your replies
I have read what you said in your replies.
as mentioned, this subject is discussed in the address in the docstring of the first thread.
In that address, the person after all explanations, has a question like this again: how and why does Python in line 22 (super().form1()) go to method form1 in class child2? I have read about MRO and know some about it. but still, i don't know why Python in line 22 goes to child2-form1 .

[Gribouillis]

but still, i don't know why Python in line 22 goes to child2-form1 .

That's because you read the documentation but you don't understand it.

At line 22, python will run super(child1, self).form1() . It means that it will search and call method form1() in the part of the __mro__ of self that comes after child1. This part of the __mro__ is child2 -> parent -> object. As there is a method named form1() in child2, it is this method that gets called.

[akbarza]

but still, i don't know why Python in line 22 goes to child2-form1 .

That's because you read the documentation but you don't understand it.

At line 22, python will run super(child1, self).form1() . It means that it will search and call method form1() in the part of the __mro__ of self that comes after child1. This part of the __mro__ is child2 -> parent -> object. As there is a method named form1() in child2, it is this method that gets called.

hi
in the code there is super().form1() . you said

At line 22, python will run super(child1, self).form1()

. how does Python recognize this argument for super() in that line?

[Gribouillis]

how does Python recognize this argument for super() in that line?

It is a very good question. I don't know the complete answer however the documentation of super() gives this example (with this exact comment)

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

Furthermore, if you type help(super) in the Python console, it says

class super(object)
 |  super() -> same as super(__class__, <first argument>)
 |  super(type) -> unbound super object
 |  super(type, obj) -> bound super object; requires isinstance(obj, type)
 |  super(type, type2) -> bound super object; requires issubclass(type2, type)
...

this suggests that it uses a local hidden variable named __class__. This variable can indeed be accessed in a method

>>> class A:
...     def foo(self):
...         print(__class__)
... 
>>> A().foo()
<class '__main__.A'>
>>> 

Further investigation indicates that this variable is loaded from a place called 'fast locals storage'

>>> import dis
>>> dis.dis(A.foo)
  3           0 LOAD_GLOBAL              0 (print)
              2 LOAD_DEREF               0 (__class__)
              4 CALL_FUNCTION            1
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> 

LOAD_DEREF(i)
Loads the cell contained in slot i of the “fast locals” storage. Pushes a reference to the object the cell contains on the stack.