A Curious Case of The Mutable’s

In Python, the code a = [1] * 5 evals to ; essentially five copies of the same object. Consider the following code:

1# init a 2D list of zeros
2matrix = [[0] * 5] * 5

It simply creates a matrix with all values defaulted to zero.

Now, if we simply change the element at to ,

1# change the element at (0, 0) to 2
2matrix[0][0] = 2

and plot the array:

The output is not what you expect. Instead of changing the element at to , the entire first row is updated to !

The Curious Case of Mutables

Alright let’s unravel this. The line [0] * 5 creates five references to the object . An object is just some data residing in some memory location. And a reference is a pointer to that object. In the above case, all five copies point to the same memory location (which contains an object ).

And [[0] * 5] * 5 just creates five references to that object (the internal list ).

As a consequence, mutating any one list affects all the lists.

1matrix[0] is matrix[1] # compares if two objects are infact the same object
2# True
3matrix[0][0] is matrix[1][0]
4# True

Now, consider the following case

1# init a vector of zeros
2vector = [0] * 5

Again, Python just creates five references to the same , as seen above (& below).

1vector[0] is vector[1]
2# True

So, if we change the first element to , it should essentially change the list to , right?

1# change the first element to 2
2vector[0] = 2

Which actually results in

Huh. How come mutating the object didn’t affect the other copies, in this case?

Because integers are immutable objects, i.e., you cannot mutate them (okay poor use of ‘i.e.’). Whereas Python lists are mutable objects. If you mutate an immutable object, it snaps all existing references (pointers) to that object & creates a new object instead (with a new reference).

Hence, when we mutated a list it overrode the original object & all pointers continued pointing to the same location, ignorant. But mutating an int de-referenced existing pointers & created a new object with a new reference to it.

1vector[0] is vector[1]
2# False

Visualising Stackframes

Case 1: mutating a mutable object

1l = [[0] * 5] * 5
2l[0][0] = 2
3fcol = [x[0] for x in l]
4print(fcol)

playground

Case 2: mutating an immutable object

1l = [0] * 5
2l[0] = 2
3f = l[0]
4print(l)

playground