NumPy Arrays: una introducción [con ejemplos]

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

Como primer paso, aprenderá cómo las matrices NumPy funcionan de manera diferente a las listas de Python. Luego aprenderá varias formas de crear matrices NumPy y realizar operaciones básicas en ellas.

¡Vamos a empezar!

Conceptos básicos de 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 arreglos N-dimensionales (arreglos ND). Tienen capacidades de transmisión y nos permiten vectorizar operaciones para aumentar la velocidad y utilizar funciones matemáticas integradas para mejorar el rendimiento.

Para comenzar 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, abre tu terminal y ejecuta el siguiente comando:

 pip3 install numpy

Después de instalar NumPy, puede importarlo a su entorno de trabajo con 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 NumPy

Considere la siguiente lista de números de Python:

 py_list = [1,2,3,4]

Puede obtener una matriz NumPy 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 verificar el tipo de np_arr1 , llame a la función type() incorporada, verá que es ndarray , la estructura de datos fundamental en NumPy.

 type(np_arr1) # numpy.ndarray

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

• Una lista de Python puede contener objetos de diferentes tipos de datos, mientras que una matriz NumPy contiene elementos del mismo tipo de datos. El tipo de datos predeterminado es float con una precisión de 64 bits (float64).
• Los elementos de una lista de Python no se almacenan necesariamente en ubicaciones contiguas en 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 otras diferencias.

Radiodifusión

Una característica poderosa de las matrices NumPy es la transmisión. Supongamos que nos gustaría agregar 2 a todos los elementos de np_arr1 y py_list .

Intentemos agregar 2 a py_list y veamos qué sucede:

 >>> py_list + 2

Vemos que obtenemos un TypeError que indica que solo podemos concatenar dos listas, y no se admite agregar py_list + 2 como este.

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

Probemos la misma operación en la matriz, np_arr1 .

 >>> np_arr1 + 2

En el resultado, vemos que se ha agregado 2 a cada elemento de la matriz.

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

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

Vectorización

Las matrices NumPy admiten la vectorización para operaciones más rápidas con elementos. Supongamos que nos gustaría encontrar la suma de elementos de las dos matrices.

Usar una simple operación + en 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 en la matriz NumPy, np_arr1 , devuelve la suma de elementos de np_arr1 consigo misma.

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

De manera similar, las listas anidadas pueden tener una estructura similar 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 puede crear matrices NumPy a partir de listas de Python existentes usando np.array(list-obj) . Sin embargo, esta no es la forma más eficiente.

En su lugar, puede usar varias funciones integradas 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 cómo usar algunas de estas funciones integradas.

Creación de matrices de ceros y unos

Suele ser útil crear una matriz de dimensiones específicas rellenadas solo con ceros o solo con unos. Y luego utilícelos y modifíquelos en pasos posteriores en el programa.

Podemos usar la función 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 a atributos como dtype y shape , usando 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 usar 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 de identidad

La matriz identidad se usa ampliamente en varias aplicaciones en álgebra lineal. Y puede usar la función np.eye() para crear una matriz de identidad. La función np.eye() toma solo un argumento: el orden de la matriz ( n ).

 arrayi = np.eye(3) print(arrayi)

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

Crear 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 comúnmente utilizadas son la distribución uniforme y la distribución normal estándar.

La función randn() , que forma parte del módulo random de NumPy, se puede utilizar para generar matrices de números que se muestrean 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 muestra de números de una 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 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 del argumento de size y los números enteros toman valores en el intervalo [low,high) .

Aquí hay 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, repasemos algunas otras funciones útiles para crear matrices NumPy.

La función arange() devuelve una matriz de números entre un valor start y stop en pasos de un valor de step : start , start + step , start + 2*step hasta pero sin incluir stop . Los valores de start y step son opcionales . El tamaño de paso predeterminado es 1 y el valor inicial predeterminado es 0.

En este ejemplo, array_a es una matriz de números que comienza en 1 y va 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 usando np.linspace() . Use np.linspace(start, stop, num) num obtener una matriz de números espaciados uniformemente entre los valores de start y stop .

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 manera 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( arange() , la función linspace() incluye el punto final de forma predeterminada.

Operaciones básicas en matrices NumPy

A continuación, repasemos algunas de las operaciones básicas en matrices NumPy.

Encontrar los elementos mínimos y máximos

Siempre que usemos 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(seed_value) .

En el siguiente ejemplo, establecí la semilla para la reproducibilidad, int_arr1 es una matriz de siete números 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 en la matriz, puede llamar al método max() en el objeto de la matriz, int_arr1 y
• Para encontrar el elemento mínimo en la matriz, puede llamar al método min() en el objeto de la matriz, int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

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

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

Aquí, el elemento máximo 73 ocurre 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 usar np.argmax(array) y np.argmin(array) para encontrar los índices de los elementos máximo y mínimo, respectivamente. Obtenga 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 arreglos verticalmente usando la función vstack() .

Aquí hay 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.ones((2,3)) arr2 = np.zeros((2,3))

Podemos concatenar estas dos matrices verticalmente usando 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 ocurre 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.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 usando hstack

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

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

 np.hstack((arr1,arr2))

Debido a que el apilamiento ocurre horizontalmente, las matrices de entrada deben tener la misma cantidad 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.]])

usando concatenar

También puede usar matrices NumPy concatenadas a lo largo de un eje específico usando la función concatenate() . Establezca el argumento del axis opcional en el eje que le gustaría concatenar; el valor por defecto del eje es cero.

Aquí están algunos ejemplos:

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

Cuando no especificamos el eje para concatenar, las matrices se concatenan a lo largo del eje 0. En la matriz resultante, la segunda matriz arr2 se agrega (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 = 1 , obtenemos el siguiente resultado. arr2 se concatena (como columnas) al lado de 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 las hstack() y vstack() , las dimensiones de las matrices a lo largo del eje de concatenación deben coincidir .

Conclusión

En este tutorial, aprendió las diferencias entre los arreglos NumPy y las listas de Python, con un enfoque en las ventajas de los arreglos N-dimensionales en términos de velocidad y eficiencia.

También aprendió varias funciones útiles para crear arreglos de una dimensión particular y realizar operaciones comunes, como encontrar los elementos mínimo y máximo, concatenar arreglos y más.

A continuación, aprenda a remodelar matrices NumPy.