NumPy Arrays: Una Introducción [Con Ejemplos]

¿Quieres empezar con NumPy? Esta guía le enseñará los conceptos básicos de arrays NumPy en Python.

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

¡Comencemos!

Fundamentos de NumPy Arrays

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 de NumPy son las matrices N-dimensionales (matrices N-D). Tienen radiodifusión capacidades y nos permiten vectorizar para agilizar las operaciones y utilizar funciones matemáticas integradas 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 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.

import numpy as 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 de números en Python:

py_list = [1,2,3,4]

Puede obtener una matriz 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_arr1se llama a la función type() verás que es ndarrayla estructura de datos fundamental en NumPy.

type(np_arr1)
# numpy.ndarray

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

• Una lista Python puede contener objetos de diferente mientras que una matriz NumPy contiene elementos del tipo 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 contiguo en 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.

Probemos a sumar 2 a py_list y ver qué pasa:

>>> py_list + 2

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

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-c0f9974899df> in <module>
----> 1 py_list + 2

TypeError: can only concatenate list (not "int") to list

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 de la matriz.

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

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

Vectorización

Las matrices NumPy soportan la vectorización para agilizar las operaciones elemento a elemento. Supongamos que queremos encontrar la suma elemento a elemento de las dos matrices.

Utilizando un simple + 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 en la matriz NumPy, np_arr1devuelve la suma de elementos de np_arr1 consigo misma.

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

Del mismo modo, las listas anidadas pueden parecer similares en estructura a una matriz NumPy N-dimensional. Sin embargo, las diferencias discutidas hasta ahora se mantienen.

nested_list = [[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 puedes crear matrices NumPy a partir de listas Python existentes utilizando np.array(list-obj). Sin embargo, no es la forma más eficaz.

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 indica el tamaño de la matriz en 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.

Creación de matrices de ceros y unos

A menudo es ú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 el zeros() para crear una matriz de ceros. Pase la forma de la matriz requerida como una tupla: np.zeros(shape).

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, llamar atributos como dtype y shapeutilizando 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() función.

array1 = np.ones((3,3))
print(array1)

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

Crear una matriz de identidad

La matriz identidad se utiliza ampliamente en varias aplicaciones del álgebra lineal. Y se puede utilizar la np.eye() para crear una matriz de identidad. La dirección np.eye() sólo recibe 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.

En randn() que forma parte de la función random puede utilizarse para generar matrices de números que se muestrean a partir de un módulo 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 un array de números muestra de un distribución uniforme en el intervalo [0,1).

uniform_arr = 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 números 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 deduce de la variable size y los enteros toman valores en el intervalo [low,high).

He aquí un ejemplo:

int_arr = np.random.randint(1,100,(2,3))
print(int_arr)

[[53 89 33]
 [24 85 33]]

Otras funciones integradas útiles

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

En arange() devuelve una matriz de números entre start y stop en pasos de a step valor: start, start + step,  start + 2*step hasta stop. En start y el step son opcional. 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 comienza 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(start, stop, num) para obtener una matriz de num números espaciados uniformemente entre start y stop valores.

Toma, 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.  ]

Del mismo modo, 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 del arange() la función linspace() función incluye el endpoint por defecto.

Operaciones básicas con matrices NumPy

A continuación, vamos a repasar algunas de las operaciones básicas con 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 ejecutemos el código. Para obtener resultados reproducibles, debemos establecer una semilla: np.random.seed(seed_value).

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

np.random.seed(27)
int_arr1 = np.random.randint(1,100,7)
print(int_arr1)
# [20 57 73 32 57 38 25]

• Para encontrar el elemento máximo de la matriz, puede llamar a la función max() en el objeto matriz, int_arr1y
• Para encontrar el elemento mínimo de la matriz, puede llamar a la función 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 la función argmax() y el argmin() sobre el objeto matriz.

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

int_arr1.argmax()
# 2

Y el elemento mínimo 20 se produce en el índice 0.

int_arr1.argmin()
# 0

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

Cómo concatenar matrices NumPy

Otra operación común que puedes querer hacer con arrays NumPy es la concatenación.

Concatenación vertical con vstack

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

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

arr1 = np.ones((2,3))
arr2 = np.zeros((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 sea de forma (2,2). Ahora tiene dos filas y dos columnas.

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

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

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-21-d5d3bf37fc21> in <module>
----> 1 np.vstack((arr1,arr2))

ValueError: all the input array dimensions for the concatenation axis must 
match exactly, but along dimension 1, the array at index 0 has size 3 and the 
array at index 1 has size 2

Concatenación horizontal con hstack

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

arr1 = np.ones((3,3))
arr2 = np.zeros((3,2))

np.hstack((arr1,arr2))

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

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

Uso de la concatenación

También puede utilizar concatenar matrices NumPy a lo largo de un eje específico utilizando la función concatenate() función. Ajuste la opción axis al eje sobre el que desea concatenar; el argumento por defecto del eje es cero.

He aquí algunos ejemplos:

arr1 = np.ones((2,3))
arr2 = np.zeros((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 axis = 1obtenemos el siguiente resultado. arr2 se concatena (como columnas) junto a la primera matriz, arr1.

np.concatenate((arr1,arr2),axis=1)

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

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

Conclusión

En este tutorial, has aprendido las diferencias entre las matrices de NumPy y las listas de Python, con un enfoque 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.