Why are integers immutable in Python? [duplicate]

Answer 1

What are the design decisions to make numbers immutable in Python?

There are several reasons for immutability, let's see first what are the reasons for immutability?

1- Memory

• Saves memory. If it's well known that an object is immutable, it can be easily copied creating a new reference to the same object.
• Performance. Python can allocate space for an immutable object at creation time, and the storage requirements are fixed and unchanging.

2- Fast execution.

• It doesn't have to copy each part of the object, only a simple reference.
• Easy to be compared, comparing equality by reference is faster than comparing values.

3- Security:

• In Multi-threading apps Different threads can interact with data contained inside the immutable objects, without to worry about data consistency.
• The internal state of your program will be consistent even if you have exceptions.
• Classes should be immutable unless there's a very good reason to make them mutable....If a class cannot be made immutable, limit its mutability as much as possible

4- Ease to use

• Is easier to read, easier to maintain and less likely to fail in odd and unpredictable ways.
• Immutable objects are easier to test, due not only to their easy mockability, but also the code patterns they tend to enforce.

5- Keys must be immutable. Which means you can use strings, numbers or tuples as dictionary key. This is something that you want to use.

The hash table implementation of dictionaries uses a hash value calculated from the key value to find the key. If the key were a mutable object, its value could change, and thus its hash could also change. But since whoever changes the key object can’t tell that it was being used as a dictionary key, it can’t move the entry around in the dictionary. Then, when you try to look up the same object in the dictionary it won’t be found because its hash value is different. If you tried to look up the old value it wouldn’t be found either, because the value of the object found in that hash bin would be different.

---

Going back to the integers:

• Security (3), Easy to use (4) and capacity of using numbers as keys in dictionaries (5) are reasons for taken the decision of making numbers immutable.

• Has fixed memory requirements since creation time (1).

• All in Python is an object, the numbers (like strings) are "elemental" objects. No amount of activity will change the value 8 to anything else, and no amount of activity will change the string “eight” to anything else. This is because a decision in the design too.

Answer 2

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.