¿Cómo definir una matriz bidimensional?

Quiero definir una matriz bidimensional sin una longitud inicializada como esta:

Matrix = [][]

Pero no funciona...

Probé el siguiente código, pero también es incorrecto:

Matrix = [5][5]

Error:

Traceback ...

IndexError: list index out of range

Cual es mi error?

preguntado el 12 de julio de 11 a las 12:07

Uno no definir matrices, o cualquier otra cosa. Sin embargo, puede crear secuencias multidimensionales, como muestran las respuestas aquí. Recuerda esa pitón las variables no están tipificados, pero valores están fuertemente tipados. -

Estoy confundido. Viniendo de otros lenguajes: ES una diferencia entre un 1D-Array que contiene 1D-Arrays y un 2D-Array. Y AFAIK, no hay forma de tener una matriz (o lista) multidimensional en Python. Debería decirse aquí ... -

Consulte también las preguntas frecuentes de Python3 en ¿Cómo creo una lista multidimensional? -

28 Respuestas

Técnicamente, está intentando indexar una matriz no inicializada. Primero debe inicializar la lista externa con listas antes de agregar elementos; Python llama a esto "comprensión de 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)] 

Ahora puede agregar elementos a la lista:

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

Tenga en cuenta que la matriz es la dirección "y" mayor, en otras palabras, el "índice y" viene antes del "índice x".

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

Aunque puede nombrarlos como desee, lo veo de esta manera para evitar cierta confusión que podría surgir con la indexación, si usa "x" tanto para las listas internas como externas, y desea una matriz no cuadrada.

Respondido 05 ago 19, 20:08

[[0 for x in range (cols_count)] for x in range (rows_count)] - sonhir

Edición impar de ademar111190. En Python 3 no hay xrange, pero si debe usar Python 2, entonces xrange es la función correcta para usar si no desea crear objetos innecesariamente. - David

@dave Si no lo necesita con ceros, puede usar range para crear las listas internas directamente: [range(5) for x in range(5)] - Alanjds

@alanjds: eso es cierto, pero aún puede crear muchas referencias de objetos innecesarias en Python 2 para la iteración externa (intente esto con un rango MUY grande). Además, la inicialización a algún valor es casi siempre lo que desea, y la mayoría de las veces es 0. range produce una colección iterable; xrange devuelve un generador. Mi punto fue que ademar "corrigió" algo que en realidad era más correcto y eficiente en general que su corrección. - David

@ 6packkid el [0] * w parte es agradable, pero [[0] * w] * h] producirá un comportamiento inesperado. Tratar mat = [[0] * 3] * 3; mat[0][1] = 10; print(mat == [[0, 10, 0], [0, 10, 0], [0, 10, 0]]) y mat = [[0] * 3 for i in range(3)]; mat[0][1] = 10; print(mat == [[0, 10, 0], [0, 0, 0], [0, 0, 0]]). - remitente

Si realmente desea una matriz, es mejor que use numpy. Operaciones matriciales en numpy la mayoría de las veces usa un tipo de matriz con dos dimensiones. Hay muchas formas de crear una nueva matriz; uno de los más útiles es el zeros función, que toma un parámetro de forma y devuelve una matriz de la forma dada, con los valores inicializados a cero:

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

Aquí hay algunas otras formas de crear matrices y matrices 2-d (con la salida eliminada para compacidad):

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 proporciona una matrix tipo también, pero es ya no se recomienda por cualquier uso, y puede ser eliminado de numpy en el futuro.

Respondido 01 Feb 20, 16:02

Siempre que desee matrices, debe usar numpy. Esta respuesta debería ser la primera. - pat b

El hecho de que la pregunta utilice la palabra en inglés "matrix" no significa que deban utilizar np.matrix para representarlo. La forma correcta de representar una matriz en numpy es con un array. - user2357112 es compatible con Monica

@ user2357112, y como puede ver, la mayor de los ejemplos enumerados anteriormente salida arrays en lugar de matrices. Si bien no siempre se recomienda, existen razones legítimas para usar matrix - el contexto importa. - remitente

@senderle, ¿puede ampliar las razones para usar matrix? Desde @ se introdujo el operador, parece haber una razón menos desde que se escribió esta publicación. - JPP

@jpp, como se dijo anteriormente en la publicación, las personas que vienen de matlab pueden encontrarlo útil. Pero el numpy Los documentos ahora indican que la clase puede estar obsoleta y remoto en el futuro, así que lo he eliminado de la respuesta. - remitente

Aquí hay una notación más corta para inicializar una lista de listas:

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

Desafortunadamente, acortando esto a algo como 5*[5*[0]] realmente no funciona porque terminas con 5 copias de la misma lista, por lo que cuando modificas una de ellas, todas cambian, por ejemplo:

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

Respondido 12 Jul 11, 17:07

¿Podría explicar la lógica detrás de la falla del "acortamiento"? ¿Por qué Python genera copias de la misma lista en este caso, y una matriz de celdas diferentes en el caso de [0]*5? - mike622867

Los comentarios anteriores no son exactamente ciertos: [0] * 5 todavía crea una secuencia con 5 veces una referencia al mismo Objeto que representa el número 0. Pero nunca notará esto porque 0 es inmutable (yo diría que 0 se comporta como un valor - o puede pensar en él como un tipo de datos primitivo - porque es inmutable, por lo que nunca tendrá problemas con las referencias al mismo objeto en lugar de tener copias.) - dreua

más pitónico: [[0]*5 for _ in range(5)] con contador de bucle anónimo que no estás usando - Jean-François Fabre ♦

Es bueno que señale el problema de la copia superficial en el segundo ejemplo. - qué frío

gracias @dreua, estaba realmente confundido cómo [0]*5 funciona bien. Ahora entiendo porque [{0}]*8 también sería una mala idea. - kuku

Si desea crear una matriz vacía, la sintaxis correcta es

matrix = [[]]

Y si desea generar una matriz de tamaño 5 rellena con 0,

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

Respondido 12 Jul 11, 17:07

@KorayTugay Porque la matriz se representa usando listas de Python (las filas) anidadas dentro de otra lista (las columnas). - elegible

Para Python-3 use la función range en lugar de xrange func - Rakesh Chaudhari

Creo que el matrix = [[]] entonces necesita .append para crear realmente un índice. Porque de otra manera matrix[0][0] = 1 todavía no funciona. - bombardear

Si todo lo que desea es un contenedor bidimensional para contener algunos elementos, puede usar convenientemente un diccionario en su lugar:

Matrix = {}

Entonces puedes hacer:

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

Esto funciona porque 1,2 es una tupla y la está utilizando como clave para indexar el diccionario. El resultado es similar a una matriz dispersa tonta.

Como indican osa y Josap Valls, también puedes utilizar Matrix = collections.defaultdict(lambda:0) para que los elementos faltantes tengan un valor predeterminado de 0.

Vatsal señala además que este método probablemente no sea muy eficiente para matrices grandes y solo debería usarse en partes del código que no sean críticas para el rendimiento.

respondido 12 nov., 17:13

Entonces también puedes hacer import collections; Matrix = collections.defaultdict(float), para sustituir ceros por elementos no inicializados. - sergey orshansky

El acceso a un dict para tupla (1,2) como clave no tendría una complejidad de O (n) en el peor de los casos. Como internamente, hash las tuplas. Mientras que el uso de una matriz 2D daría O (1) complejidad de tiempo para acceder al índice [1,2]. Entonces, usar dict para esto no debería ser una buena opción. - Vatsal

@Vatsal wiki.python.org/moin/TimeComplexity dice que el caso promedio es O (1), pero tiene razón sobre el peor de los casos. De todos modos, a menos que estés hablando de MUCHOS ARTÍCULOS, no te importaría esta diferencia. De hecho, me preocuparía más la memoria que el tiempo de acceso. - enobayram

Además, siempre tratamos de evitar el uso de dictados hasta que la complejidad general del algoritmo sea igual o mayor que O (n ^ 2). Como 'n' veces O (n) accesos darían una complejidad O (n ^ 2). - Vatsal

@enobayram, Lo siento pero no estoy de acuerdo. El análisis asintótico siempre dará O (n ^ 2), si el peor de los casos de acceso O (n) se realiza 'n' veces. Donde el análisis amortizado puede dar un límite menor. Y hay una gran diferencia entre el caso amortizado y el promedio ... consulte antes de hacer suposiciones y comentarios vagos: Vatsal

En Python, creará una lista de listas. No es necesario que declare las dimensiones de antemano, pero puede hacerlo. Por ejemplo:

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

Ahora matriz [0] [0] == 2 y matriz [1] [0] == 3. También puede usar la sintaxis de comprensión de listas. Este ejemplo lo usa dos veces para crear una "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)]

Respondido 12 Jul 11, 17:07

extend también sería útil en el primer caso: si comienza con m = [[]], luego podría agregar a la lista interna (extender una fila) con m[0].extend([1,2]), y agregue a la lista externa (agregue una nueva fila) con m.append([3,4]), esas operaciones te dejarían con [[1, 2], [3, 4]]. - asqueado

Debe hacer una lista de listas, y la mejor manera es usar comprensiones anidadas:

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

En tu [5][5] Por ejemplo, está creando una lista con un número entero "5" dentro e intenta acceder a su quinto elemento, y eso naturalmente genera un IndexError porque no hay un quinto elemento:

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

respondido 12 nov., 17:13

En realidad, la secuencia para row_index ('i') y column_index ('j') es la siguiente: '>>> matrix = [[0 for column_index in range (5)] for row_index in range (5)]' - Aniruddha Kalburgi

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 qué un código tan largo, eso también en Python ¿usted pregunta?

Hace mucho tiempo, cuando no me sentía cómodo con Python, vi las respuestas de una sola línea para escribir la matriz 2D y me dije a mí mismo que no volvería a usar la matriz 2-D en Python. (Esas líneas individuales daban bastante miedo y no me dio ninguna información sobre lo que estaba haciendo Python. También tenga en cuenta que no estoy al tanto de estas abreviaturas).

De todos modos, aquí está el código para un principiante cuyo origen proviene de C, CPP y Java

Nota para los amantes y expertos de Python: no voten en contra solo porque escribí un código detallado.

Respondido 06 Jul 18, 22:07

La respuesta aceptada es buena y correcta, pero me tomó un tiempo entender que también podía usarla para crear una matriz completamente vacía.

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

resultados en

[[], [], []]

Respondido el 04 de diciembre de 15 a las 14:12

Así es como suelo crear matrices 2D en Python.

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

Encuentro esta sintaxis fácil de recordar en comparación con el uso de dos bucles for en una lista de comprensión.

Respondido 04 ago 19, 12:08

Uso:

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

El * 5 para la primera dimensión funciona porque en este nivel los datos son inmutables.

respondido 12 nov., 17:13

Probablemente escribiría esto como matrix = [[0]*cols for _ in range(rows)] - sha de mierda

Una reescritura para facilitar la lectura:

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

Respondido 02 Jul 16, 12:07

Para declarar una matriz de ceros (unos):

numpy.zeros((x, y))

p.ej

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

o numpy.ones ((x, y)) p. ej.

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

Incluso son posibles tres dimensiones. (http://www.astro.ufl.edu/~warner/prog/python.html ver -> Matrices multidimensionales)

Respondido el 07 de diciembre de 13 a las 20:12

Estoy en mi primer script de Python y estaba un poco confundido por el ejemplo de la matriz cuadrada, así que espero que el siguiente ejemplo te ayude a ahorrar algo de tiempo:

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

para que

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

respondido 12 nov., 17:13

Usando NumPy puede inicializar una matriz vacía como esta:

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

Y luego agregue datos como este:

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

respondido 12 nov., 17:13

¿Cuáles serían los pros y los contras de usar numpy en lugar de "comprensión de listas"? - Revolución para Monica

Puede crear una lista bidimensional vacía anidando dos o más refuerzos cuadrados o un tercer soporte ([], separados por coma) con un refuerzo cuadrado, como se muestra a continuación:

Matrix = [[], []]

Ahora suponga que desea agregar 1 a Matrix[0][0] luego escribe:

Matrix[0].append(1)

Ahora, escriba Matrix y presione Enter. La salida será:

[[1], []]

Si ingresó la siguiente declaración en su lugar

Matrix[1].append(1)

entonces la Matrix sería

[[], [1]]

Respondido 14 Jul 20, 03:07

Eso es lo diccionario está hecho para!

matrix = {}

Tu puedes definir claves y valores en dos maneras:

matrix[0,0] = value

or

matrix = { (0,0)  : value }

Resultado:

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

Respondido el 20 de junio de 20 a las 10:06

Leí en archivos separados por comas como este:

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

La lista "datos" es entonces una lista de listas con datos de índice [fila] [col]

Respondido el 04 de Septiembre de 13 a las 20:09

Si desea poder pensarlo como una matriz 2D en lugar de verse obligado a pensar en términos de una lista de listas (mucho más natural en mi opinión), puede hacer lo siguiente:

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

El resultado es una lista (no una matriz NumPy), y puede sobrescribir las posiciones individuales con números, cadenas, lo que sea.

respondido 12 nov., 17:13

se encuentran las numpy.matrix equivalente a numpy.zeros sin ceros sin ser lista? - Revolución para Monica

Uso:

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

Creo que NumPy es el camino a seguir. Lo anterior es genérico si no desea utilizar NumPy.

respondido 12 nov., 17:13

Me gusta este intento de hacer algo simple con vanilla Python sin tener que usar numpy. - rick henderson

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

Tenga cuidado con esta breve expresión, vea la explicación completa en la respuesta de @ FJ

Respondido 03 Abr '14, 20:04

Tenga cuidado de esta manera, porque Matrix[0], Matrix[1], ..., Matrix[4] todos apuntan a la misma matriz, así que después Matrix[0][0] = 3, esperarías Matrix[0][0] == Matrix[1][0] == ... == Matrix[4][0] == 3. - gongzhitaao

Gracias gongzhitaao por tu comentario. Si lo hubiera leído antes, me habría ahorrado al menos media hora. Tener una matriz donde cada fila apunta al mismo lugar en la memoria no parece ser muy útil, y si no es consciente de lo que está haciendo ¡Incluso es peligroso! Estoy bastante seguro de que esto NO es lo que quiere hacer Masoud Abasian, quien hizo la pregunta. - Adrian

Debe eliminar esta respuesta, ya que no es la respuesta correcta. Los principiantes pueden estar confundidos. - cxxl

¿A qué respuesta te refieres? No veo un usuario con el nombre "FJ" (ni siquiera en las respuestas eliminadas). - Pedro Mortensen

@PeterMortensen Creo que ya se ha eliminado. Mejor mire la respuesta (arriba, por Andrew Clark) en: stackoverflow.com/a/6667529/3693431. - jiten

usando la lista:

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

mediante el uso de dict: también puede almacenar esta información en la tabla hash para una búsqueda rápida 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'] le dará un resultado en O (1) tiempo

*nótese bien: necesitas lidiar con una colisión en la tabla hash

Respondido 05 Feb 18, 05:02

Si no tiene información sobre el tamaño antes de comenzar, cree dos listas unidimensionales.

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

Almacene toda la fila en la primera lista. Una vez hecho esto, agregue la lista 1 a la lista 1:

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

Salida:

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

Respondido 03 ago 19, 21:08

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

Será más rápido que:

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

Respondido 07 ago 19, 08:08

Respuesta duplicada de una ya respondida a continuación. También [[0]*(L) for i in range(W)] debiera ser [[0]*(L) for _ in range(W)] desde i no se usa en ninguna parte - Ayush Vatsyayan

Aquí está el fragmento de código para crear una matriz en 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 sugiera si me he perdido algo.

Respondido el 09 de diciembre de 19 a las 12:12

Prueba esto:

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

Respondido el 28 de diciembre de 18 a las 08:12

En caso de que necesite una matriz con números predefinidos, puede utilizar el siguiente 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]]

Respondido el 21 de enero de 19 a las 17:01

Función definida por el usuario para ingresar la matriz e imprimir

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

Respondido el 02 de junio de 21 a las 08:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.