Super class appears to wrongly reference properties of derived class-CodePudding

In the following python code (I'm using 3.8), an object of class B derived from class A calls methods bar and foo that access members of the parent class through the super() function. Hence, I would expect the same result as calling bar and foo directly on A. Oddly, what is returned is affected by the parameterization of p of B, which should not happen because A should shielded from its children, shouldn't it?! Here is the code to reproduce:

class A(object):
    @property
    def p(self):
        return 3

    def bar(self):
        return self.p

    def foo(self):
        return self.bar()

class B(A):
    @property
    def p(self):
        return 6

    def bar(self):
        return super().p

    def foo(self):
        return super().bar()



a, b = A(), B()

print(a.p) # prints 3, OK
print(b.p) # prints 6, OK

print(a.bar()) # prints 3, OK
print(b.bar()) # prints 3, OK, since where accessing super().p 

print(a.foo()) # prints 3, OK
print(b.foo()) # prints 6, NOT OK, because we are accessing super().bar() and expect 3

I'm out of my wits here, so if someone could iluminate on the rationale of this behavior and show a way to avoid it, this would be most helpful. Thanks a lot.

CodePudding user response：

Welcome to the intricacies of super!

super() here is a shortcut for super(B, self). It returns a proxy that will look in the class MRO for the class coming before B, so A and super().bar() will actually call:

A.bar(self)

without changing the original b object...

And A.bar(self) is actually... b.p and will give 6

If you are used to other object oriented languages like C , all happens as if all method in Python were virtual (non final in Java wordings)

CodePudding user response：

Let me try to explain:

super().attr means to look up the attr attribue in the parent. It the attr is a method, it looks up the method's code (instructions to execute). But that does not modify the passed arguments in any way, it just sets the instuctions.

In Python the self is an argument behind the scenes. If c=C(), then c.meth(...) means C.meth(c, ...), i.e. call to method meth defined in the class C with first argument c (other args follow, if any). The first arg becomes the self argument in the method implementation. The name self is just a convention, not a special keyword)

Back to the question. Here is a simplified program without properties, it behaves the same:

class A:
    P = 3 

    def bar(self):
        return self.P

    def foo(self):
        return self.bar()

class B(A):
    P = 6 

    def bar(self):
        return super().P

    def foo(self):
        return super().bar()

b.foo() invokes super().bar(), i.e. the bar() in the parent that class A. That method contains code that simply returns self.P. But self is b, so the lookup returns 6. (In your original program p is a property that returns 6)