5

I've noticed a (seemingly) strange behaviour with assignments, which has led me several times to do programming mistakes.

See the following example first :

>>> i = 0
>>> t = (i,)
>>> t
(0,)
>>> i += 1
>>> t
(0,)

As expected, the value of the unique element of t does not change, even after the value of i has been incremented.

See now the following :

>>> l = [0]
>>> t = (l,)
>>> t
([0],)
>>> l[0] += 1
>>> t
([1],)  # <- ?

I don't understand why the initial zero in t is now one ; if I had incremented it with a reference to t...

>>> t[0][0] += 1

... I'd understand that it's value has changed, but this is not the case in the preceding example, where only l is explicitly referenced when incrementing.

I've got two questions:

  1. Why is it so?
  2. Are there special rules I should be aware of concerning this?
michaelmeyer
  • 7,985
  • 7
  • 30
  • 36

2 Answers2

8

That's because integers are immutable and lists are mutable.

>>> i = 0
>>> t = (i,)
>>> t[0] is i  # both of them point to the same immutable object
True
>>> i += 1  # We can't modify an immutable object, changing `i` simply 
            # makes it point to a new object 2.
            # All other references to the original object(0) are still intact.
>>> i
1
>>> t       # t still points to the same 0
(0,)
>>> x = y = 1
>>> id(x),id(y)
(137793280, 137793280)
>>> x += 1
>>> id(x),id(y)       #y still points to the same object
(137793296, 137793280)

for lists:

>>> l = [0]
>>> t = (l,)       
>>> t[0] is l #both t[0] and l point to the same object [0]
True
>>> l[0] += 1 # modify [0] in-place
>>> t
([1],)
>>> l
[1]
#another exmple
>>> x = y =[]    # x, y point to the same object
>>> x.append(1)  # list.append modifies the list in-place
>>> x, y          
([1], [1]) 
>>> x = x + [2]  # only changes x, x now points to a new object
>>> x, y
([1, 2], [1])
Ashwini Chaudhary
  • 244,495
  • 58
  • 464
  • 504
  • So, the thing one should be aware of is if he's dealing with mutable objects (lists, set, etc.) or immutable objects (strings, integers, tuple...) ? – michaelmeyer Jun 10 '13 at 12:38
  • There's also the fact that tuples are immutable; if the object stored in the tuple was a mutable one but it did not implement `__iadd__`, the operation would still not work; however, with a custom `__iadd__` method (which modifies `self`) it does. – JAB Jun 10 '13 at 12:41
  • @doukremt You can modify an mutable object from any of it's references(in-place operations only, `append`, `extend`, `+=`), while modifying a immutable object always returns a new object and all other references still point to the old object. – Ashwini Chaudhary Jun 10 '13 at 12:44
  • In my opinion, the examples are fine; anyway, mentioning mutable/immutable does confuse the mental picture of what happens. (It was not me who downvoted.) Any assignment simply means copying a reference. Any Python variable is a string as a key and the reference value bound to the key. – pepr Jun 10 '13 at 13:17
2

In the second example, t (the tuple) holds a reference to l (the list). When you do l[0] += 1, you're changing the list, but the tuple still holds a reference to the list. In the first example, when you do i += 1, you're actually creating a new integer which your tuple doesn't hold a reference to. See this answer that I wrote a while back for a much more in-depth explanation of the += operator and how it is actually implemented.

Community
  • 1
  • 1
mgilson
  • 300,191
  • 65
  • 633
  • 696