# How to define a two-dimensional array?

## Question:

I want to define a two-dimensional array without an initialized length like this:

```
Matrix = [][]
```

But this gives an error:

IndexError: list index out of range

## Answers:

You’re technically trying to index an uninitialized array. You have to first initialize the outer list with lists before adding items; Python calls this

"list comprehension".

```
# Creates a list containing 5 lists, each of 8 items, all set to 0
w, h = 8, 5
Matrix = [[0 for x in range(w)] for y in range(h)]
```

#You can now add items to the list:

```
Matrix[0][0] = 1
Matrix[6][0] = 3 # error! range...
Matrix[0][6] = 3 # valid
```

Note that the matrix is "y" address major, in other words, the "y index" comes before the "x index".

```
print Matrix[0][0] # prints 1
x, y = 0, 6
print Matrix[x][y] # prints 3; be careful with indexing!
```

Although you can name them as you wish, I look at it this way to avoid some confusion that could arise with the indexing, if you use "x" for both the inner and outer lists, and want a non-square Matrix.

If you want to create an empty matrix, the correct syntax is

```
matrix = [[]]
```

And if you want to generate a matrix of size 5 filled with 0,

```
matrix = [[0 for i in xrange(5)] for i in xrange(5)]
```

You should make a list of lists, and the best way is to use nested comprehensions:

```
>>> matrix = [[0 for i in range(5)] for j in range(5)]
>>> pprint.pprint(matrix)
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
```

On your `[5][5]`

example, you are creating a list with an integer “5” inside, and try to access its 5th item, and that naturally raises an IndexError because there is no 5th item:

```
>>> l = [5]
>>> l[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
```

In Python you will be creating a list of lists. You do not have to declare the dimensions ahead of time, but you can. For example:

```
matrix = []
matrix.append([])
matrix.append([])
matrix[0].append(2)
matrix[1].append(3)
```

Now matrix[0][0] == 2 and matrix[1][0] == 3. You can also use the list comprehension syntax. This example uses it twice over to build a “two-dimensional list”:

```
from itertools import count, takewhile
matrix = [[i for i in takewhile(lambda j: j < (k+1) * 10, count(k*10))] for k in range(10)]
```

If you really want a matrix, you might be better off using `numpy`

. Matrix operations in `numpy`

most often use an array type with two dimensions. There are many ways to create a new array; one of the most useful is the `zeros`

function, which takes a shape parameter and returns an array of the given shape, with the values initialized to zero:

```
>>> import numpy
>>> numpy.zeros((5, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
```

Here are some other ways to create 2-d arrays and matrices (with output removed for compactness):

```
numpy.arange(25).reshape((5, 5)) # create a 1-d range and reshape
numpy.array(range(25)).reshape((5, 5)) # pass a Python range and reshape
numpy.array([5] * 25).reshape((5, 5)) # pass a Python list and reshape
numpy.empty((5, 5)) # allocate, but don't initialize
numpy.ones((5, 5)) # initialize with ones
```

`numpy`

provides a `matrix`

type as well, but it is no longer recommended for *any* use, and may be removed from `numpy`

in the future.

Here is a shorter notation for initializing a list of lists:

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

Unfortunately shortening this to something like `5*[5*[0]]`

doesn’t really work because you end up with 5 copies of the same list, so when you modify one of them they all change, for example:

```
>>> matrix = 5*[5*[0]]
>>> matrix
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
>>> matrix[4][4] = 2
>>> matrix
[[0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2]]
```

I read in comma separated files like this:

```
data=[]
for l in infile:
l = split(',')
data.append(l)
```

The list “data” is then a list of lists with index data[row][col]

To declare a matrix of zeros (ones):

```
numpy.zeros((x, y))
```

e.g.

```
>>> numpy.zeros((3, 5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
```

or

numpy.ones((x, y))

e.g.

```
>>> np.ones((3, 5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
```

Even three dimensions are possible.

(http://www.astro.ufl.edu/~warner/prog/python.html see –> Multi-dimensional arrays)

```
# Creates a list containing 5 lists initialized to 0
Matrix = [[0]*5]*5
```

Be careful about this short expression, see full explanation down in @F.J’s answer

I’m on my first Python script, and I was a little confused by the square matrix example so I hope the below example will help you save some time:

```
# Creates a 2 x 5 matrix
Matrix = [[0 for y in xrange(5)] for x in xrange(2)]
```

so that

```
Matrix[1][4] = 2 # Valid
Matrix[4][1] = 3 # IndexError: list index out of range
```

If all you want is a two dimensional container to hold some elements, you could conveniently use a dictionary instead:

```
Matrix = {}
```

Then you can do:

```
Matrix[1,2] = 15
print Matrix[1,2]
```

This works because `1,2`

is a tuple, and you’re using it as a key to index the dictionary. The result is similar to a dumb sparse matrix.

As indicated by osa and Josap Valls, you can also use `Matrix = collections.defaultdict(lambda:0)`

so that the missing elements have a default value of `0`

.

Vatsal further points that this method is probably not very efficient for large matrices and should only be used in non performance-critical parts of the code.

Use:

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

The *5 for the first dimension works because at this level the data is immutable.

Use:

```
import copy
def ndlist(*args, init=0):
dp = init
for x in reversed(args):
dp = [copy.deepcopy(dp) for _ in range(x)]
return dp
l = ndlist(1,2,3,4) # 4 dimensional list initialized with 0's
l[0][1][2][3] = 1
```

I do think NumPy is the way to go. The above is a generic one if you don’t want to use NumPy.

The accepted answer is good and correct, but it took me a while to understand that I could also use it to create a completely empty array.

```
l = [[] for _ in range(3)]
```

results in

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

**A rewrite for easy reading:**

```
# 2D array/ matrix
# 5 rows, 5 cols
rows_count = 5
cols_count = 5
# create
# creation looks reverse
# create an array of "cols_count" cols, for each of the "rows_count" rows
# all elements are initialized to 0
two_d_array = [[0 for j in range(cols_count)] for i in range(rows_count)]
# index is from 0 to 4
# for both rows & cols
# since 5 rows, 5 cols
# use
two_d_array[0][0] = 1
print two_d_array[0][0] # prints 1 # 1st row, 1st col (top-left element of matrix)
two_d_array[1][0] = 2
print two_d_array[1][0] # prints 2 # 2nd row, 1st col
two_d_array[1][4] = 3
print two_d_array[1][4] # prints 3 # 2nd row, last col
two_d_array[4][4] = 4
print two_d_array[4][4] # prints 4 # last row, last col (right, bottom element of matrix)
```

If you want to be able to think it as a 2D array rather than being forced to think in term of a list of lists (much more natural in my opinion), you can do the following:

```
import numpy
Nx=3; Ny=4
my2Dlist= numpy.zeros((Nx,Ny)).tolist()
```

The result is a list (not a NumPy array), and you can overwrite the individual positions with numbers, strings, whatever.

## That’s what **dictionary** is made for!

```
matrix = {}
```

You can define **keys** and **values** in two ways:

```
matrix[0,0] = value
```

or

```
matrix = { (0,0) : value }
```

Result:

```
[ value, value, value, value, value],
[ value, value, value, value, value],
...
```

If you don’t have size information before start then create two one-dimensional lists.

```
list 1: To store rows
list 2: Actual two-dimensional matrix
```

Store the entire row in the 1st list. Once done, append list 1 into list 2:

```
from random import randint
coordinates=[]
temp=[]
points=int(raw_input("Enter No Of Coordinates >"))
for i in range(0,points):
randomx=randint(0,1000)
randomy=randint(0,1000)
temp=[]
temp.append(randomx)
temp.append(randomy)
coordinates.append(temp)
print coordinates
```

Output:

```
Enter No Of Coordinates >4
[[522, 96], [378, 276], [349, 741], [238, 439]]
```

Using NumPy you can initialize empty matrix like this:

```
import numpy as np
mm = np.matrix([])
```

And later append data like this:

```
mm = np.append(mm, [[1,2]], axis=1)
```

by using list :

```
matrix_in_python = [['Roy',80,75,85,90,95],['John',75,80,75,85,100],['Dave',80,80,80,90,95]]
```

by using dict:

you can also store this info in the hash table for fast searching like

```
matrix = { '1':[0,0] , '2':[0,1],'3':[0,2],'4' : [1,0],'5':[1,1],'6':[1,2],'7':[2,0],'8':[2,1],'9':[2,2]};
```

matrix[‘1’] will give you result in O(1) time

***nb**: you need to deal with a collision in the hash table

This is how I usually create 2D arrays in python.

```
col = 3
row = 4
array = [[0] * col for _ in range(row)]
```

I find this syntax easy to remember compared to using two for loops in a list comprehension.

Here’s the code for a beginner whose coming from C, CPP and Java background

```
rows = int(input())
cols = int(input())
matrix = []
for i in range(rows):
row = []
for j in range(cols):
row.append(0)
matrix.append(row)
print(matrix)
```

Why such a long code, that too in `Python`

you ask?

Long back when I was not comfortable with Python, I saw the single line answers for writing 2D matrix and told myself I am not going to use 2-D matrix in Python again. (Those single lines were pretty scary and It didn’t give me any information on what Python was doing. Also note that I am not aware of these shorthands.)

```
l=[[0]*(L) for _ in range(W)]
```

Will be faster than:

```
l = [[0 for x in range(L)] for y in range(W)]
```

Try this:

```
rows = int(input('Enter rowsn'))
my_list = []
for i in range(rows):
my_list.append(list(map(int, input().split())))
```

In case if you need a matrix with predefined numbers you can use the following code:

```
def matrix(rows, cols, start=0):
return [[c + start + r * cols for c in range(cols)] for r in range(rows)]
assert matrix(2, 3, 1) == [[1, 2, 3], [4, 5, 6]]
```

You can create an empty two dimensional list by nesting two or more square bracing or third bracket (`[]`

, separated by comma) with a square bracing, just like below:

```
Matrix = [[], []]
```

Now suppose you want to append 1 to `Matrix[0][0]`

then you type:

```
Matrix[0].append(1)
```

Now, type Matrix and hit Enter. The output will be:

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

If you entered the following statement instead

```
Matrix[1].append(1)
```

then the Matrix would be

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

Here is the code snippet for creating a matrix in python:

```
# get the input rows and cols
rows = int(input("rows : "))
cols = int(input("Cols : "))
# initialize the list
l=[[0]*cols for i in range(rows)]
# fill some random values in it
for i in range(0,rows):
for j in range(0,cols):
l[i][j] = i+j
# print the list
for i in range(0,rows):
print()
for j in range(0,cols):
print(l[i][j],end=" ")
```

Please suggest if I have missed something.

User Define function to input Matrix and print

```
def inmatrix(m,n):
#Start function and pass row and column as parameter
a=[] #create a blank matrix
for i in range(m): #Row input
b=[]#blank list
for j in range(n): # column input
elm=int(input("Enter number in Pocket ["+str(i)+"]["+str(j)+"] ")) #Show Row And column number
b.append(elm) #add value to b list
a.append(b)# Add list to matrix
return a #return Matrix
def Matrix(a): #function for print Matrix
for i in range(len(a)): #row
for j in range(len(a[0])): #column
print(a[i][j],end=" ") #print value with space
print()#print a line After a row print
m=int(input("Enter number of row")) #input row
n=int(input("Enter number of column"))
a=inmatrix(m,n) #call input matrix function
print("Matrix is ... ")
Matrix(a) #print matrix function
```

Usually, the go-to module is NumPy:

```
import numpy as np
# Generate a random matrix of floats
np.random.rand(cols,rows)
# Generate a random matrix of integers
np.random.randint(1, 10, size=(cols,rows))
```

If you want to create a 2d matrix which dimension is defined by two variables and initialise it with a default value for all its elements. You can use this simple syntax

```
n_rows=3
n_cols=4
aux_matrix= [[1]*n_cols]*n_rows
```