Eu quero definir uma matriz bidimensional sem um comprimento inicializado como este:

Matrix = [][]

mas não funciona...

Eu tentei o código abaixo, mas também está errado:

Matrix = [5][5]

Erro:

Traceback ...

IndexError: list index out of range

Qual é o meu erro?

Tecnicamente, você está tentando indexar uma matriz não inicializada. Você precisa primeiro inicializar a lista externa com listas antes de adicionar itens; Python chama isso de "compreensão da lista".

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

Agora você pode adicionar itens à lista:

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

Observe que a matriz é o endereço "y" principal, ou seja, o "índice y" vem antes do "índice x".

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

Embora você possa nomeá-los como quiser, analiso desta maneira para evitar confusão que possa surgir com a indexação, se você usar "x" para as listas interna e externa e desejar uma matriz não quadrada.

Se você realmente quer uma matriz, pode ser melhor usá-lo numpy. As operações de matriz na numpymaioria das vezes usam um tipo de matriz com duas dimensões. Existem muitas maneiras de criar uma nova matriz; uma das mais úteis é a zerosfunção, que pega um parâmetro de forma e retorna uma matriz da forma especificada, com os valores inicializados em 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.]])

Aqui estão algumas outras maneiras de criar matrizes e matrizes 2-d (com a saída removida para compactar):

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

numpytambém fornece um matrixtipo, mas não é mais recomendado para nenhum uso e pode ser removido numpyno futuro.

Aqui está uma notação mais curta para inicializar uma lista de listas:

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

Infelizmente, encurtar isso para algo como 5*[5*[0]]realmente não funciona, porque você acaba com 5 cópias da mesma lista; portanto, quando você modifica uma delas, todas elas mudam, por exemplo:

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

Se você deseja criar uma matriz vazia, a sintaxe correta é

matrix = [[]]

E se você deseja gerar uma matriz de tamanho 5 preenchida com 0,

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

Se tudo o que você deseja é um contêiner bidimensional para conter alguns elementos, use um dicionário conveniente:

Matrix = {}

Então você pode fazer:

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

Isso funciona porque 1,2é uma tupla e você está usando-a como uma chave para indexar o dicionário. O resultado é semelhante a uma matriz esparsa muda.

Conforme indicado por osa e Josap Valls, você também pode usar Matrix = collections.defaultdict(lambda:0)para que os elementos ausentes tenham um valor padrão de 0.

Vatsal aponta ainda que esse método provavelmente não é muito eficiente para matrizes grandes e deve ser usado apenas em partes do código que não são críticas para o desempenho.

No Python, você criará uma lista de listas. Você não precisa declarar as dimensões antes do tempo, mas pode. Por exemplo:

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

Agora matriz [0] [0] == 2 e matriz [1] [0] == 3. Você também pode usar a sintaxe de compreensão da lista. Este exemplo usa duas vezes para criar uma "lista bidimensional":

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

A resposta aceita é boa e correta, mas demorei um pouco para entender que eu também poderia usá-la para criar uma matriz completamente vazia.

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

resulta em

[[], [], []]

Você deve fazer uma lista de listas e a melhor maneira é usar as compreensões aninhadas:

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

Nas suas [5][5] exemplo, você está criando uma lista com um número inteiro "5" dentro e tenta acessar seu quinto item, e isso naturalmente gera um IndexError porque não há um quinto item:

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

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)

Por que um código tão longo, que também em Python você também pergunta?

Muito tempo atrás, quando eu não estava confortável com o Python, vi as respostas de linha única para escrever a matriz 2D e disse a mim mesma que não usaria a matriz 2-D no Python novamente. (Essas linhas únicas eram bastante assustadoras e não me deram nenhuma informação sobre o que o Python estava fazendo. Observe também que não conheço essas taquigrafia).

De qualquer forma, aqui está o código para um iniciante que tem experiência em C, CPP e Java

Nota para amantes e especialistas em Python: Por favor, não vote abaixo apenas porque escrevi um código detalhado.

Uma reescrita para facilitar a leitura:

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

Usar:

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

O * 5 para a primeira dimensão funciona porque nesse nível os dados são imutáveis.

Para declarar uma matriz de zeros (uns):

numpy.zeros((x, y))

por exemplo

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

ou numpy.ones ((x, y)), por exemplo

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

Até três dimensões são possíveis. ( http://www.astro.ufl.edu/~warner/prog/python.html, consulte -> Matrizes multidimensionais)

É assim que costumo criar matrizes 2D em python.

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

Acho essa sintaxe fácil de lembrar em comparação com o uso de dois para loops em uma compreensão de lista.

Estou no meu primeiro script Python e fiquei um pouco confuso com o exemplo de matriz quadrada, então espero que o exemplo abaixo ajude você a economizar algum tempo:

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

de modo a

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

Usando o NumPy, você pode inicializar a matriz vazia assim:

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

E depois acrescente dados como este:

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

Eu li em arquivos separados por vírgula assim:

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

A lista "dados" é então uma lista de listas com dados de índice [linha] [col]

Se você quiser pensar nisso como uma matriz 2D, em vez de ser forçado a pensar no termo de uma lista de listas (muito mais natural na minha opinião), faça o seguinte:

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

O resultado é uma lista (não uma matriz NumPy) e você pode sobrescrever as posições individuais com números, cadeias de caracteres, o que for.

É para isso que serve o dicionário !

matrix = {}

Você pode definir chaves e valores de duas maneiras:

matrix[0,0] = value

ou

matrix = { (0,0)  : value }

Resultado:

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

Usar:

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

Eu acho que NumPy é o caminho a percorrer. O acima é genérico se você não quiser usar o NumPy.

usando a lista:

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

usando dict: você também pode armazenar essas informações na tabela de hash para pesquisas rápidas como

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

matriz ['1'] resultará em tempo O (1)

* nb : você precisa lidar com uma colisão na tabela de hash

Se você não tiver informações de tamanho antes do início, crie duas listas unidimensionais.

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

Armazene a linha inteira na 1ª lista. Quando terminar, anexe a lista 1 na lista 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

Resultado:

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

Tenha cuidado com esta expressão curta, veja a explicação completa na resposta de @ FJ

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

Será mais rápido que:

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

Você pode criar uma lista bidimensional vazia aninhando dois ou mais colchetes ou terceiro colchete ( []separados por vírgula) por um colchete , assim como abaixo:

Matrix = [[], []]

Agora, suponha que você queira anexar 1 Matrix[0][0]e digitar:

Matrix[0].append(1)

Agora, digite Matrix e pressione Enter. A saída será:

[[1], []]

Tente o seguinte:

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

Caso precise de uma matriz com números predefinidos, você pode usar o seguinte código:

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

Aqui está o trecho de código para criar uma matriz em 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=" ")

Por favor, sugira se eu perdi alguma coisa.