Crea matrices en Python con NumPy

Por Alejandro van den Akker

NumPy es una librería de Python por no decir la librería por excelencia cuando tenemos que tratar con matrices. Muchas empresas de Big Data, científicos e ingenieros de datos, hacen uso de esta librería por su gran potencial a la hora de realizar operaciones con matrices y por su alta capacidad de procesamiento.

Antes de comenzar es recomendable que conozcas sobre las listas de Python, ya que es fundamental para que puedas dar tus primeros pasos con matrices.

Te recomiendo que leas Listas y estructuras de datos en Python 3.

NumPy en la nube

Como ya comenté en artículos pasados suelo trabajar en la nube en un 95% con tecnologías como: Colab, Anaconda o Amazon SageMake. Asi que si como yo, utilizas uno de estos tres entornos de desarrollo no necesitaras instalar nada, solo importar la librería de la siguiente forma:

import numpy as np

¿Por qué as np? sencillamente porque acortaremos el nombre de numpy a np. Veámoslo en el siguiente ejemplo:

# Caso sin "as"
import numpy
A = numpy.empty((n, m))

# Caso con "as"
import numpy as np
A = np.empty((n, m))

Con esto ya podrías empezar a trabajar con matrices en Python.

Matrices con NumPy

Una matriz sirve para almacenar múltiples valores en listas y para Python, se considera una lista de listas, pero aquí, asumimos que empelaremos las matrices para realizar cálculos matemáticos con la librería NumPy.

Para crear una matriz vacía emplearemos el método empty(), al que le indicaremos como argumento en una tupla las dimensiones de la misma.

# Matriz vacia 4x4 
A = np.empty((4,4))
print(A)
# Salida con valores residuales
[[4.66603952e-310 1.03977794e-312 1.01855798e-312 9.54898106e-313]
 [1.12465777e-312 1.03977794e-312 1.23075756e-312 1.08221785e-312]
 [1.03977794e-312 9.76118064e-313 1.18831764e-312 1.12465777e-312]
 [1.12465777e-312 2.22809558e-312 2.14321575e-312 0.00000000e+000]]

También podemos crear una matriz vacía con las mismas dimensiones de una ya definida con el método empty_like():

# Su salida es la misma que la anterior
B = np.empty_like(A)
print(B)

Si queremos una matriz nula, es decir llena de ceros, usaremos el método zeros() al que le indicaremos como argumento en una dupla sus dimensiones, al igual que el método empty.

A = np.zeros((4, 4))
print(A)
# Salida
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

También podemos crear una matriz con las mimas dimensiones de una ya definida con zeros_like():

# Su salida es la misma que la anterior
B = np.zeros_like(A)
print(B)

Para crear una matriz de unos usaremos el método ones() que como las anteriores, indicaremos como argumento en una dupla:

A = np.ones((4, 4))
print(A)
# Salida
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

Y como en los dos últimos, el método ones_like():

B = np.ones((A))
print(B)

El método matrix() devuelve un array a partir de listas:

M = np.matrix([[0, -4, -1, 5], [6, 7, 9, -10], [-2, 12, 14, -15]])
print(M)
# Salida
[[  0  -4  -1   5]
 [  6   7   9 -10]
 [ -2  12  14 -15]]

Si queremos saber las dimensiones de una matriz, utilizaremos el método shape:

# Reutilizamos el código de la
# función matrix
M.shape
# Salida 
# 3 filas y 4 columnas
(3, 4)

Suma y multiplicación entre matrices

Con NumPy realizar cálculos matemáticos entre matrices es mucho más fácil, veamos la diferencia entre usar la librería y no.

Suma

# Suma entre matrices sin NumPy
A = [[2, 3, 4], [0.4, -2, 5], [6, 5, -3]]
B = [[23, 13, -4], [0, 1, 2], [3, -5, 3]]

row = len(A)
column = len(A[0])

if row == len(B) and column == len(B[0]):
    C = []

    for i in range(row):
        C.append([])
        for j in range(column):
            C[i].append(A[i][j] + B[i][j])
        
    print(C, end = " ")
# Salida
[[25, 16, 0], [0.4, -1, 7], [9, 0, 0]] 

Como ves, la suma del índice [0][0] de A con el [0][0] de B que es: 2 + 23 corresponde al índice [0][0] de la salida, que es 25, y así sucesivamente.

# Suma entre matrices con NumPy
A = np.matrix([[2, 3, 4], [0.4, -2, 5], [6, 5, -3]])
B = np.matrix([[23, 13, -4], [0, 1, 2], [3, -5, 3]])

sumMatrix = A + B
print("La suma entre la matriz A + B es de: \n\n{}".format(sumMatrix))
# Salida
[[25.  16.   0. ]
 [ 0.4 -1.   7. ]
 [ 9.   0.   0. ]]

Como ves el resultado es el mismo pero con una menor dificultad. Además, aprovechar el potencial de esta librería evita que cometas errores de código e infinitos bucles que recorren los índices de tus matrices.

Multiplicación

Ahora vamos a realizar una multiplicación entre dos matrices y obtener el producto en un array con el método .dot():

A = np.matrix([[2, 3, 4], [0.4, -2, 5], [6, 5, -3]])
B = np.matrix([[10, 4, 0], [0, 1, 2], [3, -5, 3]])

productMatrix = A.dot(B)
print("La multiplicación entre la matriz A + B es de: \n\n{}".format(productMatrix))
# Salida
[[ 32.   -9.   18. ]
 [ 19.  -25.4  11. ]
 [ 51.   44.    1. ]]

Conclusión

Como hemos podido ver en este artículo la librería NumPy es un gran aliado para los profesionales que trabajan con cálculo y datos. La intención era realizar una breve introducción y mostrar su potencial para posteriormente hacer uso de ella en casos prácticos o reales.

¿Te ha parecido útil?