¿Cómo inicializar una matriz bidimensional en Python?

Estoy empezando a usar Python e intento usar una lista bidimensional, que inicialmente llené con la misma variable en cada lugar. Se me ocurrió esto:

def initialize_twodlist(foo):
    twod_list = []
    new = []
    for i in range (0, 10):
        for j in range (0, 10):
            new.append(foo)
        twod_list.append(new)
        new = []

Da el resultado deseado, pero se siente como una solución alternativa. ¿Hay una manera más fácil / más corta / más elegante de hacer esto?

Un patrón que a menudo surgió en Python fue

bar = []
for item in some_iterable:
    bar.append(SOME EXPRESSION)

que ayudó a motivar la introducción de las comprensiones de listas, que convierten ese fragmento en

bar = [SOME EXPRESSION for item in some_iterable]

que es más corto y a veces más claro. Por lo general, tiene el hábito de reconocerlos y, a menudo, reemplazar los bucles con comprensiones.

Su código sigue este patrón dos veces

twod_list = []                                       \                      
for i in range (0, 10):                               \
    new = []                  \ can be replaced        } this too
    for j in range (0, 10):    } with a list          /
        new.append(foo)       / comprehension        /
    twod_list.append(new)                           /

Puedes usar una lista de comprensión :

x = [[foo for i in range(10)] for j in range(10)]
# x is now a 10x10 array of 'foo' (which can depend on i and j if you want)

¡No lo uses [[v]*n]*n, es una trampa!

>>> a = [[0]*3]*3
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[0][0]=1
>>> a
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

pero

    t = [ [0]*3 for i in range(3)]

Funciona genial.

De esta manera es más rápido que las comprensiones de la lista anidada

[x[:] for x in [[foo] * 10] * 10]    # for immutable foo!

Aquí hay algunos tiempos de python3, para listas pequeñas y grandes

$python3 -m timeit '[x[:] for x in [[1] * 10] * 10]'
1000000 loops, best of 3: 1.55 usec per loop

$ python3 -m timeit '[[1 for i in range(10)] for j in range(10)]'
100000 loops, best of 3: 6.44 usec per loop

$ python3 -m timeit '[x[:] for x in [[1] * 1000] * 1000]'
100 loops, best of 3: 5.5 msec per loop

$ python3 -m timeit '[[1 for i in range(1000)] for j in range(1000)]'
10 loops, best of 3: 27 msec per loop

Explicación:

[[foo]*10]*10crea una lista del mismo objeto repetido 10 veces. ¡No puedes usar esto, porque modificar un elemento modificará el mismo elemento en cada fila!

x[:]es equivalente list(X)pero es un poco más eficiente ya que evita la búsqueda de nombres. De cualquier manera, crea una copia superficial de cada fila, por lo que ahora todos los elementos son independientes.

Sin fooembargo, todos los elementos son el mismo objeto, por lo que si fooes mutable , no puede usar este esquema., Tendría que usar

import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]

o suponiendo una clase (o función) Fooque devuelve foos

[[Foo() for x in range(10)] for y in range(10)]

Para inicializar una matriz bidimensional en Python:

a = [[0 for x in range(columns)] for y in range(rows)]

[[foo for x in xrange(10)] for y in xrange(10)]

Por lo general, cuando desea matrices multidimensionales, no desea una lista de listas, sino más bien una matriz numpy o posiblemente un dict.

Por ejemplo, con numpy harías algo como

import numpy
a = numpy.empty((10, 10))
a.fill(foo)

Puedes hacer exactamente esto:

[[element] * numcols] * numrows

Por ejemplo:

>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]

Pero esto tiene un efecto secundario no deseado:

>>> b = [['a']*3]*3
>>> b
[['a', 'a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a']]
>>> b[1][1]
'a'
>>> b[1][1] = 'b'
>>> b
[['a', 'b', 'a'], ['a', 'b', 'a'], ['a', 'b', 'a']]

twod_list = [[foo for _ in range(m)] for _ in range(n)]

para n es el número de filas, y m es el número de columna, y foo es el valor.

Si se trata de una matriz escasamente poblada, es mejor que utilice un diccionario con una tupla:

dict = {}
key = (a,b)
dict[key] = value
...

t = [ [0]*10 for i in [0]*10]

para cada elemento se [0]*10creará un nuevo .

Enfoque incorrecto: [[Ninguno * m] * n]

>>> m, n = map(int, raw_input().split())
5 5
>>> x[0][0] = 34
>>> x
[[34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None]]
>>> id(x[0][0])
140416461589776
>>> id(x[3][0])
140416461589776

Con este enfoque, Python no permite crear un espacio de direcciones diferente para las columnas externas y dará lugar a un mal comportamiento diferente al esperado.

Enfoque correcto pero con excepción:

y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False

Es un buen enfoque, pero hay una excepción si establece el valor predeterminado en None

>>> r = [[None for i in range(5)] for j in range(5)]
>>> r
[[None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None]]
>>> id(r[0][0]) == id(r[2][0])
True

Establezca su valor predeterminado correctamente utilizando este enfoque.

Absolutamente correcto:

Sigue la respuesta del micrófono de doble bucle .

Matrix={}
for i in range(0,3):
  for j in range(0,3):
    Matrix[i,j] = raw_input("Enter the matrix:")

Para inicializar un uso de matriz bidimensional: arr = [[]*m for i in range(n)]

Realmente, arr = [[]*m]*n creará una matriz 2D en la que todas las n matrices apuntarán a la misma matriz, por lo que cualquier cambio en el valor de cualquier elemento se reflejará en todas las n listas

Para obtener más información, visite: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

usa el pensamiento más simple para crear esto.

wtod_list = []

y agrega el tamaño:

wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

o si queremos declarar el tamaño en primer lugar. solo usamos:

   wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

Como señalaron @Arnab y @Mike, una matriz no es una lista. Pocas diferencias son 1) las matrices son de tamaño fijo durante la inicialización 2) las matrices normalmente admiten operaciones menores que una lista.

Tal vez una exageración en la mayoría de los casos, pero aquí hay una implementación básica de matriz 2d que aprovecha la implementación de matriz de hardware utilizando python ctypes (bibliotecas c)

import ctypes
class Array:
    def __init__(self,size,foo): #foo is the initial value
        self._size = size
        ArrayType = ctypes.py_object * size
        self._array = ArrayType()
        for i in range(size):
            self._array[i] = foo
    def __getitem__(self,index):
        return self._array[index]
    def __setitem__(self,index,value):
        self._array[index] = value
    def __len__(self):
        return self._size

class TwoDArray:
    def __init__(self,columns,rows,foo):
        self._2dArray = Array(rows,foo)
        for i in range(rows):
            self._2dArray[i] = Array(columns,foo)

    def numRows(self):
        return len(self._2dArray)
    def numCols(self):
        return len((self._2dArray)[0])
    def __getitem__(self,indexTuple):
        row = indexTuple[0]
        col = indexTuple[1]
        assert row >= 0 and row < self.numRows() \
               and col >=0 and col < self.numCols(),\
               "Array script out of range"
        return ((self._2dArray)[row])[col]

if(__name__ == "__main__"):
    twodArray = TwoDArray(4,5,5)#sample input
    print(twodArray[2,3])

Lo importante que entendí es: al inicializar una matriz (en cualquier dimensión) Deberíamos dar un valor predeterminado a todas las posiciones de la matriz. Entonces solo se completa la inicialización. Después de eso, podemos cambiar o recibir nuevos valores en cualquier posición de la matriz. El siguiente código me funcionó perfectamente

N=7
F=2

#INITIALIZATION of 7 x 2 array with deafult value as 0
ar=[[0]*F for x in range(N)]

#RECEIVING NEW VALUES TO THE INITIALIZED ARRAY
for i in range(N):
    for j in range(F):
        ar[i][j]=int(input())
print(ar)

Si usa numpy , puede crear fácilmente matrices 2d:

import numpy as np

row = 3
col = 5
num = 10
x = np.full((row, col), num)

X

array([[10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10]])

row=5
col=5
[[x]*col for x in [b for b in range(row)]]

Lo anterior le dará una matriz 2D de 5x5

[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]]

Está utilizando la comprensión de la lista anidada. Desglose de la siguiente manera:

[[x]*col for x in [b for b in range(row)]]

[x] * col -> la expresión final que se evalúa
para x en -> x será el valor proporcionado por el iterador
[b para b en el rango (fila)]] -> Iterador.

[b para b en rango (fila)]] esto se evaluará a [0,1,2,3,4] ya que fila = 5,
así que ahora se simplifica a

[[x]*col for x in [0,1,2,3,4]]

Esto evaluará a [[0] * 5 para x en [0,1,2,3,4]] -> con x = 0 1ª iteración
[[1] * 5 para x en [0,1,2, 3,4]] -> con x = 1 2da iteración
[[2] * 5 para x en [0,1,2,3,4]] -> con x = 2 3ra iteración
[[3] * 5 para x en [0,1,2,3,4]] -> con x = 3 4ta iteración
[[4] * 5 para x en [0,1,2,3,4]] -> con x = 4 5ta iteración

Esto es lo mejor que he encontrado para enseñar a nuevos programadores y sin usar bibliotecas adicionales. Aunque me gustaría algo mejor.

def initialize_twodlist(value):
    list=[]
    for row in range(10):
        list.append([value]*10)
    return list

Aquí hay una manera más fácil:

import numpy as np
twoD = np.array([[]*m]*n)

Para inicializar todas las celdas con cualquier valor 'x' use:

twoD = np.array([[x]*m]*n

A menudo uso este enfoque para inicializar una matriz bidimensional

n=[[int(x) for x in input().split()] for i in range(int(input())]

El patrón general para agregar dimensiones podría extraerse de esta serie:

x = 0
mat1 = []
for i in range(3):
    mat1.append(x)
    x+=1
print(mat1)


x=0
mat2 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp.append(x)
        x+=1
    mat2.append(tmp)

print(mat2)


x=0
mat3 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp2 = []
        for k in range(5):
            tmp2.append(x)
            x+=1
        tmp.append(tmp2)
    mat3.append(tmp)

print(mat3)

Puedes probar esto [[0] * 10] * 10. Esto devolverá la matriz 2D de 10 filas y 10 columnas con valor 0 para cada celda.

lst = [[0] * m para i en el rango (n)]

inicializar toda la matriz n = filas ym = columnas

Otra forma es usar un diccionario para contener una matriz bidimensional.

twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0

Esto solo puede contener cualquier valor 1D, 2D y para inicializar esto 0o cualquier otro valor int, use colecciones .

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1

Código:

num_rows, num_cols = 4, 2
initial_val = 0
matrix = [[initial_val] * num_cols for _ in range(num_rows)]
print(matrix) 
# [[0, 0], [0, 0], [0, 0], [0, 0]]

initial_val debe ser inmutable

from random import randint
l = []

for i in range(10):
    k=[]
    for j in range(10):
        a= randint(1,100)
        k.append(a)

    l.append(k)




print(l)
print(max(l[2]))

b = []
for i in range(10):
    a = l[i][5]
    b.append(a)

print(min(b))