字典和类的意外Python行为

Question

class test:
    def __init__(self):
        self.see=0
        self.dic={"1":self.see}

examine=test()
examine.see+=1
print examine.dic["1"]
print examine.see

this has as a result 0 and 1 and it makes no sense why.

    print id(examine.dic["1"])
    print id(examine.see)

they also have different memory addresses

However, if you use the same example but you have an array instead of variable in see. You get the expected output.

Any explanations?

This gives the expected output:

class test:
    def __init__(self):
        self.see=[0]
        self.dic={"1":self.see}

examine=test()
examine.see[0]+=1
print examine.dic["1"][0]
print examine.see[0]

Answer 1

Short answer:

Arrays/ list s are mutable whereas integers/ int s are not.

Answer 2

lists are mutable (they can be changed in place), when you change a list the same object gets updated (the id doesn't change, because a new object is not needed).

Integers are immuable - this means to change the value of something, you have to create a new object, which will have a different id. Strings work the same way and you would have had the same "problem" if you set self.see = 'a' , and then did examine.see += ' b'

>>> a = 'a'
>>> id(a)
3075861968L
>>> z = a
>>> id(z)
3075861968L
>>> a += ' b'
>>> id(a)
3075385776L
>>> id(z)
3075861968L
>>> z
'a'
>>> a
'a b'

In Python, names point to values; and values are managed by Python. The id() method returns a unique identifier of the value and not the name .

Any number of names can point to the same value . This means, you can have multiple names that are all linked to the same id.

When you first create your class object, the name see is pointing to the value of an integer object, and that object's value is 1 . Then, when you create your class dic , the "1" key is now pointing to the same object that see was pointing to; which is 1 .

Since 1 (an object of type integer) is immutable - whenever you update it, the original object is replaced and a new object is created - this is why the return value of id() changes.

Python is smart enough to know that there are some other names pointing to the "old" value, and so it keeps that around in memory.

However, now you have two objects; and the dictionary is still pointing to the "old" one, and see is now pointing to the new one.

When you use a list, Python doesn't need to create a new object because it can modify a list without destroying it; because lists are mutable. Now when you create a list and point two names to it, both the names are pointing to the same object. When you update this object (by adding a value, or deleting a value or changing its value) the same object is updated - and so everything pointing to it will get the "updated" value.

Answer 3

examine.dic["1"] and examine.see do indeed have different locations, even if the former's initial value is copied from the latter.

With your case of using an array, you're not changing the value of examine.see : you're instead changing examine.see[0] , which is changing the content of the array it points to (which is aliased to examine.dic["1"] ).

Answer 4

When you do self.dic={"1":self.see} , the dict value is set to the value of self.see at that moment. When you later do examine.see += 1 , you set examine.see to a new value. This has no effect on the dict because the dict was set to the value of self.see ; it does not know to "keep watching" the name self.see to see if is pointing to a different value.

If you set self.see to a list, and then do examine.see += [1] , you are not setting examine.see to a new value, but are changing the existing value. This will be visible in the dict, because, again, the dict is set to the value , and that value can change.

The thing is that sometimes a += b sets a to a new value, and sometimes it changes the existing value. Which one happens depends on the type of a ; you need to know what examine.see is to know what examine.see += something does.

Answer 5

Others have addressed the mutability/boxing question. What you seem to be asking for is late binding . This is possible, but a little counterintuitive and there's probably a better solution to your underlying problem… if we knew what it was.

class test:
  @property
  def dic(self):
    self._dic.update({'1': self.see})
    return self._dic
  def __init__(self):
    self.see = 0
    self._dic = {}

>>> ex=test()
>>> ex.see
0
>>> ex.see+=1
>>> ex.see
1
>>> ex.dic
{'1': 1}
>>> ex.see+=1
>>> ex.dic
{'1': 2}

In fact, in this contrived example it's even a little dangerous because returning self._dic the consumer could modify the dict directly. But that's OK, because you don't need to do this in real life. If you want the value of self.see , just get the value of self.see .

In fact, it looks like this is what you want:

class test:
  _see = 0
  @property
  def see(self):
    self._see+=1
    return self._see

or, you know, just itertools.count() :P

Answer 6

This solution worked for me. Feel free to use it.

class integer:
    def __init__(self, integer):
        self.value=integer
    def plus(self):
        self.value=self.value+1
    def output(self):
        return self.value

The solution replaces the mutable type int with a class whose address is used as reference. Furthermore you can make changes to the class object and the changes apply to what the dictionary points. It is somewhat a pointer/datastructure.