Adam Preble wrote:
> If you don't know, you can trap what super() returns some time and poke it
> with a stick. If you print it you'll be able to tell it's definitely
> unique: <super: <class 'Child'>, <Child object>>
>
> If you try to invoke methods on it, it'll invoke the superclass' methods.
> That's what is supposed to happen and basically what already happens when
> you do super().invoke_this_thing() anyways.
>
> Okay, so how is it doing the lookup for that? The child instance and the
> super types' __dict__ are the same. The contents pass an equality
> comparison and are the same if you print them.
I think the fundamental insight is that given
class A:
foo = "A"
class B(A):
foo = "B"
def super_foo(self): return super().foo
def my_foo(self): return self.foo
b = B()
b.foo = "inst"
print(b.super_foo()) # A
print(b.my_foo()) # inst
del b.foo
print(b.my_foo()) # B
del B.foo
print(b.my_foo()) # A
self.foo looks up the attribute in the instance, falls back to the class and
then works its way up to the parent class, whereas
super().foo bypasses both instance and class, and starts its lookup in the
parent class.
--
https://mail.python.org/mailman/listinfo/python-list
