Argthtjtr

size = 3

matrix_surprise = [[0] * size] * size

matrix = [[0]*size for i in range(size)]

Live Python Tutor Visualize

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.

[[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.

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])

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

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.

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 ids 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("tt[{}]: {}".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.

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]]

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

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]]