python: class attributes and instance attributes

python

Python's class attributes and object attributes are stored in separate dictionaries. For the object f1, these can be accessed via, respectively, f1.__class__.__dict__ and f1.__dict__. Executing print f1.__class__ is Foo will output True.

When you reference the attribute of an object, Python first tries to look it up in the object dictionary. If it does not find it there, it checks the class dictionary (and so on up the inheritance heirarchy).

When you assign to f1.a, you are adding an entry to the object dictionary for f1. Subsequent lookups of f1.a will find that entry. Lookups of f2.a will still find the class attribute — the entry in the class attribute dictionary.

You can cause the value of f1.a to revert to 1 by deleting it:

del f1.a

This will remove the entry for a in the object dictionary of f1, and subsequent lookups will continue on to the class dictionary. So, afterwards, print f1.a will output 1.

You're not doing the same thing in your second example. In you first example, you are assigning f1.a a new value:

f1.a = 5

In your second example, you are simply extending a list:

f1.a.append(5)

This doesn't change what f1.a is pointing to. If you were instead to do this:

f1.a = [5]

You would find that this behaves the same as your first example.

But consider this example:

>>> f1=Foo()
>>> f2=Foo()
>>> Foo.a = 5
>>> f1.a
5
>>> f2.a
5

In this example, we're actually changing the value of the class attribute, and the change is visible in all instances of the class. When you type:

f1.a = 5

You're overriding the class attribute with an instance attribute.

>>> class Foo:
...     a=1
... 
>>> f1=Foo()
>>> f2=Foo()
>>> f1.a    # no instance attribute here in f1, so look up class attribute in Foo
1
>>> f1.a=5  # create new instance attribute in f1
>>> f1.a    # instance attribute here. Great, let's use this.
5
>>> f2.a    # no instance attribute in f2, look up class attribute in Foo
1
>>>
>>> class Foo:
...     a=[]
... 
>>> f1=Foo()
>>> f2=Foo()
>>> f1.a            # no instance attribute - look up class attribute in Foo
[]
>>> f1.a.append(5)  # no instance attribute, modify class attribute in-place
>>> f1.a            # no instance attribute - look up class attribute in Foo
[5]
>>> f2.a            # same here
[5]

My advice: to understand such cases, do tests using id, and __dict__ too :

class Foo:
    a=1

# Foo.a == 1
# id(Foo.a) == 10021840
# Foo.__dict__ == {'a': 1, '__module__': '__main__', '__doc__': None}


f1 = Foo()

# f1.a == 1
# id(f1.a) == 10021840
# f1.__dict__ == {}

f2 = Foo()

# f2.a == 1
# id(f2.a) == 10021840
# f2.__dict__ == {}

f1.a = 5

# f1.a == 5
# id(f1.a) == 10021792
# f1.__dict__ == {'a': 5}

# f2.a == 1
# id(f2.a) == 10021840
# f2.__dict__ == {}

This shows that as long as the instruction f1.a = 5 has not been executed, the instance f1 doesn't have a personal attribute a.

Then, why does the instruction print f1.a executed before f1.a = 5 produce 1?
That's because:

A class instance has a namespace implemented as a dictionary which is the first place in which attribute references are searched. When an attribute is not found there, and the instance’s class has an attribute by that name, the search continues with the class attributes.

http://docs.python.org/reference/datamodel.html#the-standard-type-hierarchy

python: class attributes and instance attributes

Related

Recent Posts