# List of lists changes reflected across sublists unexpectedly

I needed to create a list of lists in Python, so I typed the following:

``````myList = [[1] * 4] * 3
``````

The list looked like this:

``````[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
``````

Then I changed one of the innermost values:

``````myList[0][0] = 5
``````

Now my list looks like this:

``````[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]
``````

which is not what I wanted or expected. Can someone please explain what's going on, and how to get around it?

-
Possible Duplicate with more explanation //allinonescript.com/questions/17702937/… – Aseem Bansal

``````[[1] * 4] * 3
``````

or even:

``````[[1, 1, 1, 1]] * 3
``````

Creates a list that references the internal `[1,1,1,1]` 3 times - not three copies of the inner list, so any time you modify the list (in any position), you'll see the change three times.

It's the same as this example:

``````>>> inner = [1,1,1,1]
>>> outer = [inner]*3
>>> outer
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
>>> inner[0] = 5
>>> outer
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]
``````

where it's probably a little less surprising.

-
You can use the "is" operator to discover this. ls[0] is ls[1] returns True. – mipadi

When you write `[x]*3` you get, essentially, the list `[x, x, x]`. That is, a list with 3 references to the same `x`. When you then modify this single `x` it is visible via all three references to it.

To fix it, you need to make sure that you create a new list at each position. One way to do it is

``````[[1]*4 for n in range(3)]
``````

which will reevaluate `[1]*4` each time instead of evaluating it once and making 3 references to 1 list.

You might wonder why `*` can't make independent objects the way the list comprehension does. That's because the multiplication operator `*` operates on objects, without seeing expressions. When you use `*` to multiply `[[1] * 4]` by 3, `*` only sees the 1-element list `[[1] * 4]` evaluates to, not the `[[1] * 4` expression text. `*` has no idea how to make copies of that element, no idea how to reevaluate `[[1] * 4]`, and no idea you even want copies, and in general, there might not even be a way to copy the element.

The only option `*` has is to make new references to the existing sublist instead of trying to make new sublists. Anything else would be inconsistent or require major redesigning of fundamental language design decisions.

In contrast, a list comprehension reevaluates the element expression on every iteration. `[[1] * 4 for n in range(3)]` reevaluates `[1] * 4` every time for the same reason `[x**2 for x in range(3)]` reevaluates `x**2` every time. Every evaluation of `[1] * 4` generates a new list, so the list comprehension does what you wanted.

Incidentally, `[1] * 4` also doesn't copy the elements of `[1]`, but that doesn't matter, since integers are immutable. You can't do something like `1.value = 2` and turn a 1 into a 2.

-
Thanks for the explanation and the workaround. I am still surprised though that the outer list ends up holding three references to an anonymous inner list. – Charles Anderson
I am surprised that no body points out that, the answer here is misleading. `[x]*3` store 3 references like `[x, x, x]` is only right when `x` is mutable. This does't work for e.g. `a=[4]*3`, where after `a[0]=5`, `a=[5,4,4].` – Allanqunzi
Technically, it's still correct. `[4]*3` is essentially equivalent to `x = 4; [x, x, x]`. It's true, though, that this will never cause any problem since `4` is immutable. Also, your other example isn't really a different case. `a = [x]*3; a[0] = 5` won't cause problems even if `x` is mutable, since you're not modifying `x`, only modifying `a`. I wouldn't describe my answer as misleading or incorrect - you just can't shoot yourself in the foot if you're dealing with immutable objects. – CAdaker
@Allanqunzi you are wrong. Do `x = 1000; lst = [x]*2; lst[0] is lst[1]` -> `True`. Python does not distinguish between mutable and immutable objects here whatsoever. – timgeb
Technically, you could turn a `1` into a `2`, but it isn't as simple as `1.value = 2`. – Zach Gates

Actually, this is exactly what you would expect. Let's decompose what is happening here:

You write

``````lst = [[1] * 4] * 3
``````

This is equivalent to:

``````lst1 = [1]*4
lst = [lst1]*3
``````

This means `lst` is a list with 3 elements all pointing to `lst1`. This means the two following lines are equivalent:

``````lst[0][0] = 5
lst1[0] = 5
``````

As `lst[0]` is nothing but `lst1`.

To obtain the desired behavior, you can use list comprehension:

``````lst = [ [1]*4 for n in xrange(3) ]
``````

In this case, the expression is re-evaluated for each n, leading to a different list.

-
This is really clear for a beginner like me. Thank you! – Petite Etincelle
Just a small addition to the nice answer here: it's evident that you're dealing with same object if you do `id(lst[0][0])` and `id(lst[1][0])` or even `id(lst[0])` and `id(lst[1])` – Sergiy Kolodyazhnyy
``````size = 3
matrix_surprise = [[0] * size] * size
matrix = [[0]*size for i in range(size)]
``````

Live Python Tutor Visualize

-
I've put your image inline. For future reference, you really need to explain what you're linking to. – Blckknght
Great tool! Thanks for the reference – Dennis
So, why if we write matrix= [[x] * 2] doesn't make 2 elemnts for the same object like the example you describe, it seems to be the same concept, what am i missing? – Ahmed Mohamed
@AhmedMohamed Indeed it does make a list with two elements of the exact same object that `x` refers to. If you make a globally unique object with `x = object()` and then make `matrix = [[x] * 2]` these does come as true: `matrix[0][0] is matrix[0][1]` – nadrimajstor
@nadrimajstor so why the change in matrix[0] doesn't affect matrix[1] like the example above with 2d matrix. – Ahmed Mohamed
@AhmedMohamed Surprise come when you make a "copy" of mutable sequence (in our example it is a `list`) so if a `row = [x] * 2` than a `matrix = [row] * 2` where both rows are exactly the same object, and now changes to one row `matrix[0][0] = y` suddenly reflect in the other one `(matrix[0][0] is matrix[1][0]) == True` – nadrimajstor
@AhmedMohamed Take a look at Ned Batchelder - Facts and Myths about Python names and values as it might offer a better explanation. :) – nadrimajstor

Actually, think it in another case. Assume that if your list is this;

``````[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
``````

and if you write `myList[0][0] = 5` output will be;

``````>>>
[[5, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
>>>
``````

As you expected. But since you define your list variable like this;

``````[[1] * 4] * 3
``````

Python will process your codes on this pattern. So if you write `myList[0][0]` and your list defined like above, Python will process it like `[1]*3`. That's why all of the lists first elements are changed.

-
Badly explained... – user3917838

Let us rewrite your code in the following way:

``````x = 1
y = [x]
z = y * 4

myList = [z] * 3
``````

Then having this, run the following code to make everything more clear. What the code does is basically print the `id`s of the obtained objects, which

Return the “identity” of an object

and will help us identify them and analyse what happens:

``````print("myList:")
for i, subList in enumerate(myList):
print("\t[{}]: {}".format(i, id(subList)))
for j, elem in enumerate(subList):
print("\t\t[{}]: {}".format(j, id(elem)))
``````

And you will get the following output:

``````x: 1
y: [1]
z: [1, 1, 1, 1]
myList:
[0]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[1]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[2]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
``````

So now let us go step-by-step. You have `x` which is `1`, and a single element list `y` containing `x`. Your first step is `y * 4` which will get you a new list `z`, which is basically `[x, x, x, x]`, i.e. it creates a new list which will have 4 elements, which are references to the initial `x` object. The net step is pretty similar. You basically do `z * 3`, which is `[[x, x, x, x]] * 3` and returns `[[x, x, x, x], [x, x, x, x], [x, x, x, x]]`, for the same reason as for the first step.

-
Initially I was thinking, how is it possible to come up with these random numbers from your simple example. You really have to mention what `id` does before you throw this code at people. – PascalvKooten
@PascalvKooten thanks, done :) – bagrat

Alongside the accepted answer that explained the problem correctly, within your list comprehension, if You are using python-2.x use `xrange()` that returns a generator which is more efficient (`range()` in python 3 does the same job) `_` instead of the throwaway variable `n`:

``````[[1]*4 for _ in xrange(3)]      # and in python3 [[1]*4 for _ in range(3)]
``````

Also, as a much more Pythonic way you can use `itertools.repeat()` to create an iterator object of repeated elements :

``````>>> a=list(repeat(1,4))
[1, 1, 1, 1]
>>> a[0]=5
>>> a
[5, 1, 1, 1]
``````

P.S. Using numpy, if you only want to create an array of ones or zeroes you can use `np.ones` and `np.zeros` and/or for other number use `np.repeat()`:

``````In [1]: import numpy as np

In [2]:

In [2]: np.ones(4)
Out[2]: array([ 1.,  1.,  1.,  1.])

In [3]: np.ones((4, 2))
Out[3]:
array([[ 1.,  1.],
[ 1.,  1.],
[ 1.,  1.],
[ 1.,  1.]])

In [4]: np.zeros((4, 2))
Out[4]:
array([[ 0.,  0.],
[ 0.,  0.],
[ 0.,  0.],
[ 0.,  0.]])

In [5]: np.repeat([7], 10)
Out[5]: array([7, 7, 7, 7, 7, 7, 7, 7, 7, 7])
``````
-

Python containers contain references to other objects. See this example:

``````>>> a = []
>>> b = [a]
>>> b
[[]]
>>> a.append(1)
>>> b
[[1]]
``````

In this `b` is a list that contains one item that is a reference to list `a`. The list `a` is mutable.

The multiplication of a list by an integer is equivalent to adding the list to itself multiple times (see common sequence operations). So continuing with the example:

``````>>> c = b + b
>>> c
[[1], [1]]
>>>
>>> a[0] = 2
>>> c
[[2], [2]]
``````

We can see that the list `c` now contains two references to list `a` which is equivalent to `c = b * 2`.

Python FAQ also contains explanation of this behavior: How do I create a multidimensional list?

-

I guess everybody explain what is happening. I suggest one way to solve it:

`myList = [[1 for i in range(4)] for j in range(3)]`

``````myList[0][0] = 5
``````

`print myList`

And then you have:

``````[[5, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
``````
-

In simple words this is happening because in python everything works by reference, so when you create a list of list that way you basically end up with such problems.

To solve your issue you can do either one of them: 1. Use numpy array documentation for numpy.empty 2. Append the list as you get to a list. 3. You can also use dictionary if you want

-

By using the inbuilt list function you can do like this

``````a
out:[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
#Displaying the list

a.remove(a[0])
out:[[1, 1, 1, 1], [1, 1, 1, 1]]
# Removed the first element of the list in which you want altered number

a.append([5,1,1,1])
out:[[1, 1, 1, 1], [1, 1, 1, 1], [5, 1, 1, 1]]
# append the element in the list but the appended element as you can see is appended in last but you want that in starting

a.reverse()
out:[[5, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
#So at last reverse the whole list to get the desired list
``````
-
This works, but doesn't explain what's happening. – Luigi Ballabio
okay i am updating the code with comments – anand tripathi

Trying to explain it more descriptively,

Operation 1:

``````x = [[0, 0], [0, 0]]
print(type(x)) # <class 'list'>
print(x) # [[0, 0], [0, 0]]

x[0][0] = 1
print(x) # [[1, 0], [0, 0]]
``````

Operation 2:

``````y = [[0] * 2] * 2
print(type(y)) # <class 'list'>
print(y) # [[0, 0], [0, 0]]

y[0][0] = 1
print(y) # [[1, 0], [1, 0]]
``````

Noticed why doesn't modifying the first element of the first list didn't modify the second element of each list? That's because `[0] * 2` really is a list of two numbers, and a reference to 0 cannot be modified.

If you want to create clone copies, try Operation 3:

``````import copy
y = [0] * 2
print(y)   # [0, 0]

y = [y, copy.deepcopy(y)]
print(y) # [[0, 0], [0, 0]]

y[0][0] = 1
print(y) # [[1, 0], [0, 0]]
``````

another interesting way to create clone copies, Operation 4:

``````import copy
y = [0] * 2
print(y) # [0, 0]

y = [copy.deepcopy(y) for num in range(1,5)]
print(y) # [[0, 0], [0, 0], [0, 0], [0, 0]]

y[0][0] = 5
print(y) # [[5, 0], [0, 0], [0, 0], [0, 0]]
``````
-

`myList = [[1]*4] * 3` creates one list object `[1,1,1,1]` in memory and copies its reference 3 times over. This is equivalent to `obj = [1,1,1,1]; myList = [obj]*3`. Any modification to `obj` will be reflected at three places, wherever `obj` is referenced in the list. The right statement would be:

``````myList = [[1]*4 for _ in range(3)]
``````

or

``````myList = [[1 for __ in range(4)] for _ in range(3)]
``````

Important thing to note here is that `*` operator is mostly used to create a list of literals. Since `1` is a literal, hence `obj =[1]*4` will create `[1,1,1,1]` where each `1` is atomic and not a reference of `1` repeated 4 times. This means if we do `obj[2]=42`, then `obj` will become `[1,1,42,1]` not `[42,42,42,42]` as some may assume.

-