Inicializar Matrix en Python

Hay muchas formas de declarar una array bidimensional con un número determinado de filas y columnas. Veamos algunos de ellos y también las pequeñas pero engañosas capturas que lo acompañan. 
Podemos hacerlo usando la comprensión de listas, la función de concatenación del operador * y algunas otras formas.

Método 0: 2 listas de comprensión

rows = 3
cols = 2
 
mat = [[0 for _ in range(cols)] for _ in range(rows)]
print(f'matrix of dimension {rows} x {cols} is {mat}')
 
# editing the individual elements
mat[0][0], mat[0][1] = 1,2
mat[1][0], mat[1][1] = 3,4
mat[2][0], mat[2][1] = 5,6
print(f'modified matrix is {mat}')
 
# checking the memory address of first element of a row
print(f'addr(mat[0][0]) = {id(mat[0][0])}, addr(mat[0][1]) = {id(mat[0][1])}')
print(f'addr(mat[1][0]) = {id(mat[1][0])}, addr(mat[1][1]) = {id(mat[1][1])}')
print(f'addr(mat[2][0]) = {id(mat[2][0])}, addr(mat[2][1]) = {id(mat[2][1])}')

matrix of dimension 3 x 2 is [[0, 0], [0, 0], [0, 0]]
modified matrix is [[1, 2], [3, 4], [5, 6]]
addr(mat[0][0]) = 11094304, addr(mat[0][1]) = 11094336
addr(mat[1][0]) = 11094368, addr(mat[1][1]) = 11094400
addr(mat[2][0]) = 11094432, addr(mat[2][1]) = 11094464

Método 1: 1 lista de comprensión en el interior y 1 operación de concatenación en el exterior

rows = 3
cols = 2
 
mat = [[0 for _ in range(cols)]]*rows
print(f'matrix with dimension {rows} x {cols} is {mat}')
 
# editing the individual elements
mat[0][0], mat[0][1] = 1,2
mat[1][0], mat[1][1] = 3,4
mat[2][0], mat[2][1] = 5,6
print(f'modified matrix is {mat}')
 
# checking the memory address of first element of a row
print(f'addr(mat[0][0]) = {id(mat[0][0])}, addr(mat[0][1]) = {id(mat[0][1])}')
print(f'addr(mat[1][0]) = {id(mat[1][0])}, addr(mat[1][1]) = {id(mat[1][1])}')
print(f'addr(mat[2][0]) = {id(mat[2][0])}, addr(mat[2][1]) = {id(mat[2][1])}')

matrix with dimension 3 x 2 is [[0, 0], [0, 0], [0, 0]]
modified matrix is [[5, 6], [5, 6], [5, 6]]
addr(mat[0][0]) = 11094432, addr(mat[0][1]) = 11094464
addr(mat[1][0]) = 11094432, addr(mat[1][1]) = 11094464
addr(mat[2][0]) = 11094432, addr(mat[2][1]) = 11094464

Método 2: 1 lista de comprensión en el exterior y 1 operación de concatenación en el interior

rows = 3
cols = 2
 
mat = [[0]*cols for _ in range(rows)]
print(f'matrix with dimension {rows} x {cols} is {mat}')
 
# editing the individual elements
mat[0][0], mat[0][1] = 1,2
mat[1][0], mat[1][1] = 3,4
mat[2][0], mat[2][1] = 5,6
print(f'modified matrix is {mat}')
 
# checking the memory address of first element of a row
print(f'addr(mat[0][0]) = {id(mat[0][0])}, addr(mat[0][1]) = {id(mat[0][1])}')
print(f'addr(mat[1][0]) = {id(mat[1][0])}, addr(mat[1][1]) = {id(mat[1][1])}')
print(f'addr(mat[2][0]) = {id(mat[2][0])}, addr(mat[2][1]) = {id(mat[2][1])}')

matrix with dimension 3 x 2 is [[0, 0], [0, 0], [0, 0]]
modified matrix is [[1, 2], [3, 4], [5, 6]]
addr(mat[0][0]) = 11094304, addr(mat[0][1]) = 11094336
addr(mat[1][0]) = 11094368, addr(mat[1][1]) = 11094400
addr(mat[2][0]) = 11094432, addr(mat[2][1]) = 11094464

Método 3: 2 operaciones de concatenación

rows = 3
cols = 2
 
mat = [[0]*cols]*rows
print(f'matrix with dimension {rows} x {cols} is {mat}')
 
# editing the individual elements
mat[0][0], mat[0][1] = 1,2
mat[1][0], mat[1][1] = 3,4
mat[2][0], mat[2][1] = 5,6
print(f'modified matrix is {mat}')
 
# checking the memory address of first element of a row
print(f'addr(mat[0][0]) = {id(mat[0][0])}, addr(mat[0][1]) = {id(mat[0][1])}')
print(f'addr(mat[1][0]) = {id(mat[1][0])}, addr(mat[1][1]) = {id(mat[1][1])}')
print(f'addr(mat[2][0]) = {id(mat[2][0])}, addr(mat[2][1]) = {id(mat[2][1])}')

matrix with dimension 3 x 2 is [[0, 0], [0, 0], [0, 0]]
modified matrix is [[5, 6], [5, 6], [5, 6]]
addr(mat[0][0]) = 11094432, addr(mat[0][1]) = 11094464
addr(mat[1][0]) = 11094432, addr(mat[1][1]) = 11094464
addr(mat[2][0]) = 11094432, addr(mat[2][1]) = 11094464

Aquí podemos ver que los resultados del Método 1 y el Método 3 son *inesperados*. 

Esperábamos que todas las filas en el tapete fueran todas diferentes después de asignarles 1,2,3,4,5,6 respectivamente. Pero en Method1 & Method3 todos son iguales a [5,6]. Esto muestra que, esencialmente, mat[0],mat[1] y mat[2] hacen referencia a la misma memoria, lo que se puede ver más al verificar sus direcciones usando la función id en python. 

 Por lo tanto, tenga mucho cuidado al usar el operador (*) . 

Para comprenderlo mejor, podemos usar arrays tridimensionales y allí tendremos 2 ^ 3 posibilidades de ordenar la comprensión de la lista y el operador de concatenación. Este es un ejercicio que dejo para el lector.

Si trabaja con numpy, podemos hacerlo usando el método de remodelación.

import numpy as np
 
rows = 3
cols = 2
size = rows*cols
 
mat = np.array([0]*size).reshape(rows,cols)