I want to define a two-dimensional array without an initialized length like this:
Matrix = [][] But this gives an error:
3IndexError: list index out of range
29 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.
14If 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]] 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)] 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.
8In 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)] 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.)
Anyways, here's the code for a beginner whose coming from C, CPP and Java background
Note to Python Lovers and Experts: Please do not down vote just because I wrote a detailed code.
0You 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 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
[[], [], []] Use:
matrix = [[0]*5 for i in range(5)] The *5 for the first dimension works because at this level the data is immutable.
1This 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.
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) 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. ( see --> Multi-dimensional arrays)
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 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]] 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) 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]
0That'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], ... 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.
1If 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.
1l=[[0]*(L) for _ in range(W)] Will be faster than:
l = [[0 for x in range(L)] for y in range(W)] 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
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]] # 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
6Here 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.
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)) Try this:
rows = int(input('Enter rows\n')) 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]] 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 
