a mutable type inside an immutable container

by

You can always modify a mutable value inside a tuple. The puzzling behavior you see with 

>>> thing[0] += 'd'

is caused by +=. The += operator does in-place addition but also an assignment — the in-place addition works just file, but the assignment fails since the tuple is immutable. Thinking of it like

>>> thing[0] = thing[0] + 'd'

explains this better. We can use the dis module from the standard library to look at the bytecode generated from both expressions. With += we get an INPLACE_ADD bytecode:

>>> def f(some_list):
...     some_list += ["foo"]
... 
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (some_list)
              3 LOAD_CONST               1 ('foo')
              6 BUILD_LIST               1
              9 INPLACE_ADD         
             10 STORE_FAST               0 (some_list)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE

With + we get a BINARY_ADD:

>>> def g(some_list):
...     some_list = some_list + ["foo"]
>>> dis.dis(g)
  2           0 LOAD_FAST                0 (some_list)
              3 LOAD_CONST               1 ('foo')
              6 BUILD_LIST               1
              9 BINARY_ADD          
             10 STORE_FAST               0 (some_list)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE

Notice that we get a STORE_FAST in both places. This is the bytecode that fails when you try to store back into a tuple — the INPLACE_ADD that comes just before works fine.

This explains why the “Doesn’t work, and works” case leaves the modified list behind: the tuple already has a reference to the list:

>>> id(thing[0])
3074072428L

The list is then modified by the INPLACE_ADD and the STORE_FAST fails:

>>> thing[0] += 'd'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

So the tuple still has a reference to the same list, but the list has been modified in-place:

>>> id(thing[0])
3074072428L
>>> thing[0] 
['b', 'c', 'd']

More Related Contents:

  1. Why can tuples contain mutable items?
  2. Does Python have an immutable list?
  3. How can I add tuples in a list? [closed]
  4. how to unpack a tuple in this form (‘abc’, [20, 20])? [closed]
  5. Immutable vs Mutable types
  6. What’s the difference between lists and tuples?
  7. Why can’t I use a list as a dict key in python?
  8. How to extract the n-th elements from a list of tuples
  9. List vs tuple, when to use each? [duplicate]
  10. How to unzip a list of tuples into individual lists? [duplicate]
  11. Append to a list defined in a tuple – is it a bug? [duplicate]
  12. Subtracting 2 lists in Python
  13. List of tuples to dictionary [duplicate]
  14. Why are python strings and tuples are made immutable?
  15. What is the inverse function of zip in python? [duplicate]
  16. How to find the maximum value in a list of tuples? [duplicate]
  17. Why is tuple faster than list in Python?
  18. What’s the difference between lists enclosed by square brackets and parentheses in Python?
  19. Convert a columns of string to list in pandas
  20. How to flatten a tuple in python
  21. Why are integers immutable in Python?
  22. Swap values in a tuple/list inside a list in python?
  23. Unexpected Behavior of Extend with a list in Python [duplicate]
  24. How does str.startswith really work?
  25. Concatenate elements of a tuple in a list in python [duplicate]
  26. If in Python I put a list inside a tuple, can I safely change the contents of that list? [duplicate]
  27. Filter a list of tuples based on condition
  28. How can I convert this string to list of lists? [duplicate]
  29. python tuple is immutable – so why can I add elements to it
  30. Converting string to tuple without splitting characters

Leave a Comment