Difference between Father. __init(self) and super(Father, self). __init__()

Question

I have a little doubt about the issue of inheritance in python.

In the following test, I hoped that quack prints the same value for the two classes I created:

class A(object):
    a,b = (None, None)
    def __init__(self):
        self.a = 'a'

    def quack(self):
        return 'retorno "%s" ' % self.a

class B(A):

    def __init__(self):
        super(A, self).__init__()
        self.b = 'b'

My test was done like this:

b = B()
a = A()

print(b.quack())
print(a.quack())

The exit was:

retorno "None" 
retorno "a"

But I thought the two should return to the same thing.

The inheritance of property a only worked as I expected when I changed the section of super for that reason:

A.__init(self)

Return:

retorno "a"
retorno "a"

Having these two cases, what is the difference between the two statements I created?

Why didn’t the super use the parent class method?

Answer 1

The problem is that the super should not be called in the parent class, but in the parent class itself:

class B(A):
    def __init__(self):
        super(B, self).__init__()
        self.b = 'b'

For the idea of super is not to call the method in a specific class (for this the second form you used is the most indicated), but rather to call the method using the same python inheritance rules, just by defacing the current class:

class A(object): ...
class B(A): ...
class C(A): ...
class D(B, C): ...
class E(B): ...

class F(D, E):
    def __init__(self):
        super(F, self).__init__()

This example above will try to find a method __init__ in all classes of the hierarchy, except for own F. And the order he seeks is defined by the process of inheritance (which unfortunately I do not know...). That would be for any other method, too, like super(F, self).foo().

class F(D, E):
    def __init__(self):
        super(E, self).__init__()

If you used this code, on the other hand, Python would only get one __init__ in the superclasses of E, that is to say, B and then A. Even though C have a __init__, and C be one of the superclasses of F, he would not be sought in this case. And in particular, the E is not sought (because the super assumes it’s to ignore E, just as he ignored F in the previous example).