¿Quiere iniciarse en NumPy? Esta guía le enseñará los fundamentos de las matrices NumPy en Python.

Como primer paso, aprenderá cómo funcionan las matrices NumPy de forma diferente a las listas de Python. A continuación, aprenderá varias formas de crear matrices NumPy y realizar operaciones básicas con ellas.

¡Comencemos!

Fundamentos de las matrices NumPy

NumPy es una de las bibliotecas de Python más populares para la computación científica y el análisis de datos. Las estructuras de datos básicas en NumPy son las matrices N-dimensionales (matrices N-D). Tienen capacidades de transmisión y nos permiten vectorizar las operaciones para ganar velocidad y utilizar funciones matemáticas incorporadas para mejorar el rendimiento.

Para empezar a trabajar con NumPy, primero debe instalar la biblioteca e importarla a su entorno de trabajo. Está disponible como un paquete PyPI que se puede instalar a través de pip.

Para instalar NumPy, abra su terminal y ejecute el siguiente comando:

pip3 install numpy

Después de instalar NumPy, puede importarlo a su entorno de trabajo bajo un alias. El alias habitual es np.

importar numpy como np

Nota: Importar NumPy bajo el alias np no es un requisito, sino una convención recomendada.

Listas de Python frente a matrices de NumPy

Considere la siguiente lista Python de números:

py_list = [1,2,3,4]

Puede obtener un array NumPy a partir de una lista existente llamando a la función np.array() con la lista como argumento.

np_arr1 = np.array(py_list)
print(np_arr1)
[1 2 3 4]

Para comprobar el tipo de np_arr1, llame a la función incorporada type(), verá que se trata de ndarray, la estructura de datos fundamental en NumPy.

type(np_arr1)
# numpy.ndarray

Aunque la lista de Python y el array de NumPy puedan parecer similares, existen ciertas diferencias:

  • Una lista Python puede contener objetos de diferentes tipos de datos, mientras que un array NumPy contiene elementos del mismo tipo de datos. El tipo de datos por defecto es float con una precisión de 64 bits (float64).
  • Los elementos de una lista Python no se almacenan necesariamente en ubicaciones contiguas de la memoria. Sin embargo, los elementos de una matriz NumPy se almacenan en un bloque contiguo en la memoria. Como resultado, es más rápido buscar y acceder a los elementos.

Repasemos un par de diferencias más.

Difusión

Una potente característica de las matrices NumPy es la difusión. Supongamos que queremos añadir 2 a todos los elementos de np_arr1 y py_list.

Intentemos añadir 2 a py_list y veamos qué ocurre:

>>> py_list 2

Vemos que obtenemos un TypeError indicando que sólo podemos concatenar dos listas, y añadir py_list 2 de esta forma no está soportado.

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-5-c0f9974899df> en <modulo&gt
---->
 1 py_list 2

TypeError: sólo se puede concatenar lista (no "int") a lista

Intentemos la misma operación en el array, np_arr1. 

>>> np_arr1 2

En el resultado, vemos que se ha añadido 2 a cada elemento del array.

array([3, 4, 5, 6])

Esto se debe a que NumPy ha transmitido implícitamente el escalar 2 a una matriz de forma compatible para obtener este resultado.

Vectorización

Las matrices NumPy admiten la vectorización para realizar operaciones elemento a elemento más rápidamente. Supongamos que queremos hallar la suma elemento a elemento de las dos matrices.

Una simple operación sobre la lista devolvería la concatenación de las dos listas (¡que no es lo que queremos!).

>>> py_list py_list
# [1, 2, 3, 4, 1, 2, 3, 4]

Pero la misma operación sobre la matriz NumPy, np_arr1, devuelve la suma elemento a elemento de np_arr1 consigo misma.

>>> np_arr1 np_arr1 
# array([2, 4, 6, 8])

De forma similar, las listas anidadas pueden parecer similares en estructura a una matriz NumPy de N dimensiones. Sin embargo, se mantienen las diferencias comentadas hasta ahora.

lista_anidada = [[1,2],[3,4],[5,6]]
np_arr2 = np.array(nested_list)
print(np_arr2)
[[1 2]
 [3 4]
 [5 6]]

Cómo crear matrices NumPy

Siempre puede crear matrices NumPy a partir de listas existentes en Python utilizando np.array(lista-obj). Sin embargo, esta no es la forma más eficiente.

En su lugar, puede utilizar varias funciones incorporadas que le permiten crear matrices de una forma específica. La forma de la matriz es una tupla que denota el tamaño de la matriz a lo largo de cada dimensión. Por ejemplo, la forma de una matriz de 2×2 con dos filas y dos columnas es (2,2). En esta sección, aprenderemos a utilizar algunas de estas funciones incorporadas.

How-to-Create-NumPy-Arrays

Creación de matrices de ceros y unos

A menudo resulta útil crear una matriz de dimensiones específicas poblada con todos ceros o todos unos. Y luego utilizarlas y modificarlas en pasos posteriores del programa.

Podemos utilizar la función zeros() para crear una matriz de ceros. Pase la forma de la matriz deseada como una tupla: np.zeros (forma).

array0 = np.zeros((3,3))
print(array0)

Aquí está la salida, una matriz 2D de ceros:

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Puede acceder a los atributos de la matriz NumPy, llame a atributos como dtype y shape, utilizando la notación de puntos, como se muestra a continuación:

print(array0.dtype)
# float64

print(array0.shape)
# (3, 3)

Para obtener una matriz de unos, puede utilizar la función np. ones().

array1 = np.ones((3,3))
print(array1)
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

Creación de una matriz identidad

La matriz identidad se utiliza ampliamente en varias aplicaciones en álgebra lineal. Y puede utilizar la función np.eye( ) para crear una matriz identidad. La función np.eye() sólo admite un argumento: el orden de la matriz(n).

arrayi = np.eye(3)
print(arrayi)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Creación de matrices de números aleatorios

También puede crear matrices de una forma específica pobladas con números aleatorios extraídos de distribuciones específicas. Las distribuciones de probabilidad más utilizadas son la distribución uniforme y la distribución normal estándar.

La función randn(), que forma parte del módulo aleatorio de NumPy, puede utilizarse para generar matrices de números muestreados a partir de una distribución normal estándar. La distribución normal estándar es una distribución gaussiana con media cero y varianza unitaria.

std_arr = np.random.randn(3,4)
print(std_arr)
[[-0.13604072 1.21884359 2.06850932 0.78212093]
 [ 0.44314719 -0.78084801 -0.70517138 1.17984949]
 [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() devuelve una matriz de números muestra de una distribución uniforme sobre el intervalo [0,1).

array_uniforme = np.random.rand(2,3)
print(uniform_arr)
[[0.90470384 0.18877441 0.10021817]
 [0.741 0.10657658 0.71334643]]

También puede crear una matriz de enteros aleatorios utilizando la función randint( ) que forma parte del módulo aleatorio de NumPy. np.random.randint(low, high, size) devuelve una matriz de enteros. La forma de la matriz se infiere del argumento tamaño y los enteros toman valores en el intervalo [bajo,alto).

He aquí un ejemplo:

int_arr = np.random.randint(1,100,(2,3))
print(int_arr)
[[53 89 33]
 [24 85 33]]

Otras funciones incorporadas útiles

A continuación, vamos a repasar algunas otras funciones útiles para crear matrices NumPy.

La función arange( ) devuelve una matriz de números entre un valor de inicio y un valor de parada en pasos de un valor de paso: inicio, paso de inicio, inicio 2*paso hasta la parada, pero sin incluirla. Los valores de inicio y paso son opcionales. El tamaño de paso por defecto es 1 y el valor de inicio por defecto es 0.

En este ejemplo, array_a es una matriz de números que empieza en 1 y llega hasta 10, pero sin incluirlo, en pasos de 0,5.

array_a = np.arange(1,10,0.5)
print(array_a)
[1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]

También puede crear matrices de números espaciados uniformemente utilizando np. linspace(). Utilice np. linspace(inicio, parada, num) para obtener una matriz de números espaciados uniformemente entre los valores de inicio y parada.

Aquí, arr_lin es una matriz de 5 números espaciados uniformemente en el intervalo [1,10].

array_lin = np.linspace(1,10,5)
print(array_lin)
[ 1. 3.25 5.5 7.75 10. ]

De forma similar, arr_lin2 es una matriz de 10 números espaciados uniformemente en el intervalo [1,20].

array_lin2 = np.linspace(1,20,10)
print(array_lin2)
[ 1.          3.11111111 5.22222222 7.33333333 9.44444444 11.55555556
 13.66666667 15.77777778 17.88888889 20.        ]

💡 A diferencia de la función arange( ), la función linspace( ) incluye el punto final por defecto.

Operaciones básicas con matrices NumPy

A continuación, vamos a repasar algunas de las operaciones básicas sobre matrices NumPy.

Encontrar los elementos mínimo y máximo

Siempre que utilicemos funciones del módulo aleatorio de NumPy para crear matrices, obtendremos un resultado diferente cada vez que se ejecute el código. Para obtener resultados reproducibles, debemos establecer una semilla: np.random.seed(valor_semilla).

En el siguiente ejemplo, he establecido la semilla para que sea reproducible, int_arr1 es una matriz de siete enteros aleatorios en el intervalo [1,100).

np.random.semilla(27)
int_arr1 = np.random.randint(1,100,7)
print(int_arr1)
# [20 57 73 32 57 38 25]
  • Para hallar el elemento máximo de la matriz, puede llamar al método max() en el objeto matriz, int_arr1, y
  • Para encontrar el elemento mínimo en la matriz, puede llamar al método min () en el objeto matriz, int_arr1.
int_arr1.max()
# 73

int_arr1.min()
# 20

Hallar el índice de los elementos máximo y mínimo

A veces, puede que necesite encontrar el índice de los elementos máximo y mínimo. Para ello, puede llamar a los métodos argmax() y argmin() en el objeto array.

Aquí, el elemento máximo 73 se encuentra en el índice 2.

int_arr1.argmax()
# 2

Y el elemento mínimo 20 ocurre en el índice 0.

int_arr1.argmin()
# 0

También puede utilizar np.argmax(array) y np.argmin(array) para encontrar los índices de los elementos máximo y mínimo, respectivamente. Más información sobre la función NumPy argmax().

Cómo concatenar matrices NumPy

Otra operación común que puede querer hacer con matrices NumPy es la concatenación.

Concatenación vertical usando vstack

Puede concatenar matrices verticalmente utilizando la función vstack ().

He aquí un ejemplo. arr1 es una matriz de unos con dos filas y tres columnas y arr2 es una matriz de ceros con dos filas y tres columnas.

arr1 = np.unos((2,3))
arr2 = np.ceros((2,3))

Podemos concatenar estas dos matrices verticalmente utilizando la función vstack () como se muestra:

np.vstack((arr1,arr2))
array([[1., 1., 1.],
       [1., 1., 1.],
       [0., 0., 0.],
       [0., 0., 0.]])

Como el apilamiento se produce verticalmente, las dos matrices deben tener el mismo número de columnas.

Cambiemos arr2 para que tenga la forma (2,2). Ahora tiene dos filas y dos columnas.

arr1 = np.ones((2,3))
arr2 = np.ceros((2,2))
np.vstack((arr1,arr2))

Por lo tanto, la concatenación vertical no es posible, y obtenemos un ValueError.

---------------------------------------------------------------------------
ValueError Traceback (última llamada más reciente)
<ipython-input-21-d5d3bf37fc21> en <module&gt
---->
 1 np.vstack((arr1,arr2))

ValueError: todas las dimensiones del array de entrada para el eje de concatenación deben 
coincidir exactamente, pero en la dimensión 1, la matriz en el índice 0 tiene tamaño 3 y la 
array en el índice 1 tiene tamaño 2

Concatenación horizontal utilizando hstack

Puede concatenar matrices NumPy horizontalmente utilizando la función hstack (), como se muestra a continuación.

arr1 = np.ones((3,3))
arr2 = np.ceros((3,2))
np.hstack((arr1,arr2))

Dado que el apilamiento se produce horizontalmente, las matrices de entrada deben tener el mismo número de filas. Aquí, tanto arr1 como arr2 tienen tres filas.

array([[1., 1., 1., 0., 0.],
       [1., 1., 1., 0., 0.],
       [1., 1., 1., 0., 0.]])

Uso de concatenar

También puede utilizar concatenar matrices NumPy a lo largo de un eje específico utilizando la función concatenate(). Establezca el argumento opcional axis en el eje a lo largo del cual desea concatenar; el valor por defecto del eje es cero.

He aquí algunos ejemplos:

arr1 = np.unos((2,3))
arr2 = np.ceros((2,3))

Cuando no especificamos el eje a lo largo del cual concatenar, las matrices se concatenan a lo largo del eje 0. En la matriz resultante, la segunda matriz arr2 se añade (como filas) debajo de la primera matriz.

np.concatenate((arr1,arr2))
array([[1., 1., 1.],
       [1., 1., 1.],
       [0., 0., 0.],
       [0., 0., 0.]])

Cuando especificamos eje = 1, obtenemos el siguiente resultado. arr2 se concatena (como columnas) junto al primer array, arr1.

np.concatenate((arr1,arr2),axis=1)
array([[1., 1., 1., 0., 0., 0.],
       [1., 1., 1., 0., 0., 0.]])

Al igual que con las funciones hstack() y vstack( ), las dimensiones de las matrices a lo largo del eje de concatenación deben coincidir.

Conclusión

En este tutorial, ha aprendido las diferencias entre las matrices de NumPy y las listas de Python, centrándose en las ventajas de las matrices N-dimensionales en términos de velocidad y eficiencia.

También ha aprendido varias funciones útiles para crear matrices de una dimensión determinada y realizar operaciones comunes, como encontrar el mínimo y el máximo de elementos, concatenar matrices, etc.

A continuación, aprenda a remodelar matrices NumPy.