Python: __dict__ shows class attribute for the object of the class even when the behavior inside the __init__ mutates the class attribute

Question

From my understanding,

For a mutable object like a list, += (augmented assignment) leads to mutation of the object if the underlying object supports mutation like list. Of course, this does not work for immutable objects which do not support mutation as __iadd__ is not present and __add__ is the one that gets called.

Consider the following code:

class TestClass:
    bar = []

    def __init__(self, x):
        self.bar += [x]


f = TestClass(1)
g = TestClass(2)
h = TestClass(3)
print(f.bar)
print(g.bar)
print(TestClass.bar)

Now, I understand why all three g,f,h print out [1, 2, 3] since we are "mutating" the class attribute.

But when I try to look at the namespace for the objects by doing print(f.__dict__) , I see the bar attribute inside the object as well.

Question 1: If the actual attribute that gets mutated is the class attribute, why does the instance get created in object namespace?

Secondly, "if" that instance variable gets created in the object(like f), then f.bar += 4 should only affect object f as the new instance variable bar in f supposedly shadowed the class attribute. But I see that doing f.bar+=4 in turn also updates the class attribute which is totally confusing to me.

Can someone please help me with this?

Answer 1

This may be a little subtle. You can think of

self.bar += [x]

As equivalent to

self.bar = self.bar.__iadd__([x])

So, self.bar.__iadd__([x]) mutates the list, essentially calling list.extend , it then returns the list object . This list object, which is the same one being referenced by TestClass.bar , is assigned to the instance attribute .

So now you have an instance attribute with the same name as the class attribute and both happen to be bound to the same list object

This is even warned for in the [documentation]:

For targets which are attribute references, the same caveat about class and instance attributes applies as for regular assignments.

With that caveat being: