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

numpy provides a matrix type as well. It's less commonly used, and some people recommend against using it. But it's useful for people coming to numpy from Matlab, and in some other contexts. I thought I'd include it since we're talking about matrices!

>>> numpy.matrix([[1, 2], [3, 4]])

matrix([[1, 2],

        [3, 4]])

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

numpy.matrix('1 2; 3 4')                 # use Matlab-style syntax

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.ndarray((5, 5))                    # use the low-level constructor

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.

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

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

[, , ]

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

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)

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)

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

Use:

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

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

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]

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.

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.

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.

# 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

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

   ...

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 to for loops in a list comprehension.

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

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

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

Will be faster than:

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