TECH4GEEKS-LOGO-HEADER
Oxary Magazine
$10 – $15 / Week

Matrices NumPy: una introducción [With Examples]

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

Primero, 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.

¡Empecemos!

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 difusión capacidades y nos permiten vectorizar operaciones para acelerar 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 paquete PyPI que es instalable 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 con un alias. El alias habitual es np.

import numpy as np

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

Listas de Python vs 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 incorporada type(), verá que es ndarray, la estructura de datos fundamental de NumPy.

type(np_arr1)
# numpy.ndarray

Aunque la lista de Python y la matriz NumPy pueden parecer similares, existen algunas 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 flotante 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. Por lo tanto, es más rápido buscar y acceder a los elementos.

Repasemos algunas otras diferencias.

Difusión

Una característica poderosa de las matrices NumPy es la transmisión. Supongamos que queremos 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 estamos obteniendo 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])

De hecho, NumPy convierte implícitamente el escalar 2 en una matriz de forma compatible para lograr este resultado.

  11 convertidores de binario a texto que debe conocer

Vectorización

Las matrices NumPy admiten la vectorización para operaciones más rápidas por elemento. Supongamos que queremos encontrar la suma por elemento 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 elemento por elemento de np_arr1 consigo mismo.

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

Todavía 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 indica el tamaño de la matriz a lo largo de cada dimensión. Por ejemplo, la forma de una tabla 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.

Cómo crear matrices NumPy

Crear arreglos de ceros y unos

Suele ser útil crear una matriz de dimensiones específicas que contengan solo ceros o unos. Luego úsalos y modifícalos en los siguientes pasos del 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á el resultado, una matriz 2D de ceros:

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

Puede acceder a los atributos de 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 es ampliamente utilizada 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.]]

Creación de tablas de números aleatorios

También puede crear matrices de una forma específica llenas de 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 aleatorio de NumPy, se puede utilizar para generar matrices de números muestreados a partir de un 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 de 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 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 tamaño y los números enteros toman valores en el rango [low,high).

  Cómo hacer análisis de datos exploratorios (EDA) en R (con ejemplos)

Here’s an example:

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, revisemos 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, inicio + paso, inicio + 2*paso hasta detener incluido. Los valores de inicio y paso 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 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) para obtener una matriz de números espaciados uniformemente entre los valores inicial y final.

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(), la función linspace() comprender el punto final predeterminado.

Operaciones básicas de matriz NumPy

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

Encuentra elementos mínimos y máximos

Cada vez que usamos funciones del módulo aleatorio de NumPy para crear matrices, obtenemos un resultado diferente cada vez que se ejecuta el código. Para obtener resultados reproducibles, necesitamos definir una semilla: np.random.seed(seed_value).

En el siguiente ejemplo, configuro 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

Encuentre el índice de elementos máximos y mínimos.

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

  11 API de código QR para generar códigos en segundos

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 realizar con matrices NumPy es la concatenación.

Concatenación vertical usando vstack

Puede concatenar arreglos verticalmente usando la función vstack().

Aquí un ejemplo. arr1 es un arreglo de unos con dos filas y tres columnas y arr2 es un arreglo 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, ambas matrices deben tener el mismo número de columnas.

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

Dado que el apilamiento ocurre horizontalmente, las matrices de entrada deben tener el mismo número de Líneas. Aquí, arr1 y arr2 tienen tres líneas.

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

Usar concatenación

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

He aquí 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 (en 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.]])

En cuanto a las funciones hstack() y vstack(), las dimensiones de los arreglos a lo largo del eje de concatenación debe 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 elementos mínimos y máximos, concatenar arreglos y más.

A continuación, aprenda a remodelar matrices NumPy.

Fuente

Etiquetas

Comparte en:

Ultimos Post

Categorias

Lorem ipsum dolor sit amet, consectetur adipiscing elit eiusmod tempor ncididunt ut labore et dolore magna
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore