unir - ¿Cómo inicializar una matriz bidimensional en Python?

unir dos matrices en python

Question

Estoy empezando python y estoy tratando de usar una lista bidimensional, que inicialmente llena 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. ¿Hay una manera más fácil / más corta / más elegante de hacer esto?

Answer 1

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 conducirá a un mal comportamiento diferente al que espera.

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

Así que establezca su valor predeterminado correctamente utilizando este enfoque.

Absolutamente correcto:

Sigue la respuesta de mike de doble bucle .

Answer 2

A menudo utilizo este enfoque para inicializar una matriz bidimensional.

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

Answer 3

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

Answer 4

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

Tal vez sea una exageración en la mayoría de los casos, pero aquí hay una implementación básica de la matriz 2d que aprovecha la implementación de la matriz de hardware usando ctypes de Python (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])

Answer 5

El patrón general para agregar dimensiones se podría dibujar 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)

Answer 6

Este es el 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

Answer 7

No 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 para i en el rango (3)] es excelente

Answer 8

Para inicializar una matriz bidimensional en Python:

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

Answer 9

Por lo general, cuando desea matrices multidimensionales no desea una lista de listas, sino 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)

Answer 10

Puede utilizar 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)

Answer 11

Puedes hacer 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'']]

Answer 12

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

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

Answer 13

Un patrón que a menudo surgía en Python era

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

que ayudó a motivar la introducción de listas de comprensión, que convierten ese fragmento de código en

bar = [SOME EXPRESSION for item in some_iterable]

que es más corto ya veces más claro. Por lo general, se acostumbra a reconocerlos y, a menudo, a reemplazar los bucles por comprensiones.

Tu 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) /

Answer 14

Usa el pensamiento más simple para crear esto.

wtod_list = []

y añadir 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)]

Answer 15

De esta manera es más rápido que las listas de comprensión anidadas.

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

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

$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]*10 crea una lista del mismo objeto repetida 10 veces. ¡No puedes simplemente usar esto, porque la modificación de un elemento modificará ese mismo elemento en cada fila!

x[:] es equivalente a 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 embargo, todos los elementos son el mismo objeto foo , así que si foo es mutable , no puedes usar este esquema. Tendrías que usar

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

o asumiendo una clase (o función) Foo que devuelve foo s

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

Answer 16

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

Answer 17

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

Answer 18

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

Answer 19

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

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

Answer 20

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.