调用 super() 后更改 self 的类型

Question

I have a little trouble with Python's inheritance model. In particular, when calling a method using super(), the method of the super class is invoked, but the self reference type does not change. Hence, calling methods using self will point to the derived class.

I guess it's easier to understand in code:

class A:
    def fun1(self, p1, p2):
        print('A:fun1')
        return f'a: {p1} {p2}'
    def fun2(self, p1):
        print('A:fun2')
        return self.fun1(p1, p1)

class B(A):
    def fun1(self, p1, p2):
        print('B:fun1')
        return super(B, self).fun1(f'b{p1}', f'b{p2}')
    def fun2(self, p1):
        print('B:fun2')
        return super(B, self).fun2(f'b{p1}')

b = B()
print(b.fun1('1', '2'))
print(b.fun2('3'))

In the above code we have to functions fun1 and fun2 , where one is an 'optimized' version of the other, calling it via self . The derived class changes the functionality of both functions but is still based on their super versions.

When executing this, we'll have this output:

B:fun1
A:fun1
a: b1 b2
B:fun2
A:fun2
B:fun1
A:fun1
a: bb3 bb3

When invoking B.fun2 using super() correctly forwards the call to A.fun2 . But: the type of self does not change and A.fun2 is now not based on A.fun1 anymore, but on B.fun1 , because self has type B .

I understand why, but is there a way to change this behaviour? I'd really like self to always call functions of the 'self' class.

Answer 1

Short answer: use __private names or store the “base” object in a field instead of subclassing.

Inheritance in python allows classes to override methods of the same name in their base classes. The lookup is done in the method resolution order .

The only names that do not follow this shadowing are names beginning with two underscores . Python internally rewwrites every attribute lookup on self from __private to _ClassName__private , so that they do not collide with each other.

The other way is to just store your base object in a field — it will then make it impossible to overwrite anything on it. But I think the double underscore way is superior, since it also exposes all the unaltered access to the base object (you can get around it by defining __getattr__(self, x) resorting to getattr(super(), x) if hiding the base object is desired).

By the way, here you can use super() without arguments. This is the simple case described in the docs .