Why are integers immutable in Python?

by

Making integers mutable would be very counter-intuitive to the way we are used to working with them.

Consider this code fragment:

a = 1       # assign 1 to a
b = a+2     # assign 3 to b, leave a at 1

After these assignments are executed we expect a to have the value 1 and b to have the value 3. The addition operation is creating a new integer value from the integer stored in a and an instance of the integer 2.
If the addition operation just took the integer at a and just mutated it then both a and b would have the value 3.

So we expect arithmetic operations to create new values for their results – not to mutate their input parameters.

However, there are cases where mutating a data structure is more convenient and more efficient. Let’s suppose for the moment that list.append(x) did not modify list but returned a new copy of list with x appended.
Then a function like this:

def foo():
  nums = []
  for x in range(0,10):
    nums.append(x)
  return nums

would just return the empty list. (Remember – here nums.append(x) doesn’t alter nums – it returns a new list with x appended. But this new list isn’t saved anywhere.)

We would have to write the foo routine like this:

def foo():
  nums = []
  for x in range(0,10):
    nums = nums.append(x)
  return nums

(This, in fact, is very similar to the situation with Python strings up until about 2.6 or perhaps 2.5.)

Moreover, every time we assign nums = nums.append(x) we would be copying a list that is increasing in size resulting in quadratic behavior.
For those reasons we make lists mutable objects.

A consequence to making lists mutable is that after these statements:

a = [1,2,3]
b = a
a.append(4)

the list b has changed to [1,2,3,4]. This is something that we live with even though it still trips us up now and then.

More Related Contents:

  1. Immutable vs Mutable types
  2. a mutable type inside an immutable container
  3. List of lists changes reflected across sublists unexpectedly
  4. What is the difference between shallow copy, deepcopy and normal assignment operation?
  5. Remove specific characters from a string in Python
  6. About the changing id of an immutable string
  7. Aren’t Python strings immutable? Then why does a + ” ” + b work?
  8. How to make an immutable object in Python?
  9. What would a “frozen dict” be?
  10. Why can tuples contain mutable items?
  11. Why does using `arg=None` fix Python’s mutable default argument issue?
  12. Hashable, immutable
  13. Why are python strings and tuples are made immutable?
  14. Python string with space and without space at the end and immutability
  15. Immutable numpy array?
  16. Why are Python strings immutable? Best practices for using them
  17. Existence of mutable named tuple in Python?
  18. Python references
  19. Why the “mutable default argument fix” syntax is so ugly, asks python newbie
  20. Correct Style for Python functions that mutate the argument
  21. Can lists be mutated? [duplicate]
  22. Does Python have an immutable list?
  23. Is making in-place operations return the object a bad idea?
  24. Python, subclassing immutable types
  25. Pandas: Modify a particular level of Multiindex
  26. Unexpected Behavior of Extend with a list in Python [duplicate]
  27. Python: why can I put mutable object in a dict or set?
  28. python tuple is immutable – so why can I add elements to it
  29. Mutable and Immutable Strings in python
  30. Why must dictionary keys be immutable?

Leave a Comment