Tutorial de NumPy: una guía simple basada en ejemplos

La biblioteca NumPy es una biblioteca popular de Python utilizada para aplicaciones informáticas científicas y es un acrónimo de "Numerical Python". La operación de NumPy...

Introducción

La biblioteca NumPy es una biblioteca popular de Python utilizada para aplicaciones informáticas científicas y es un acrónimo de "Numerical Python".

Las operaciones de NumPy se dividen en tres categorías principales: Transformación de Fourier y manipulación de formas, Operaciones lógicas y matemáticas y Álgebra lineal y generación de números aleatorios. Para hacerlo lo más rápido posible, NumPy está escrito en C y Python.

En este artículo, proporcionaremos una breve introducción a la pila NumPy y veremos cómo se puede usar la biblioteca NumPy para realizar una variedad de tareas matemáticas.

Ventajas de NumPy

NumPy tiene varias ventajas sobre el uso de funciones matemáticas básicas de Python, algunas de las cuales se describen aquí:

  1. NumPy es extremadamente rápido en comparación con el núcleo de Python gracias a su uso intensivo de extensiones C.
  2. Muchas bibliotecas avanzadas de Python, como Scikit-Learn, Scipy y Keras, hacen un uso extensivo de la biblioteca NumPy. Por lo tanto, si planea seguir una carrera en ciencia de datos o aprendizaje automático, NumPy es una muy buena herramienta para dominar.
  3. NumPy viene con una variedad de funcionalidades integradas, que en el núcleo de Python requerirían una buena cantidad de código personalizado.

Con respecto al último punto, eche un vistazo al siguiente script:

1
2
x = [2, 3, 4, 5, 6]
y = [a + 2 for a in x]

Aquí, para sumar 2 a cada elemento de la lista x, tenemos que recorrer toda la lista y sumar 2 a cada elemento individualmente. Ahora veamos cómo podemos realizar la misma tarea con la biblioteca NumPy:

1
2
3
import numpy as np
nums = np.array([2, 3, 4, 5, 6])
nums2 = nums + 2

Puede ver lo fácil que es agregar un valor escalar a cada elemento de la lista a través de NumPy. No solo es legible, sino también más rápido en comparación con el código anterior.

Esto es solo la punta del iceberg, en realidad, la biblioteca NumPy es capaz de realizar operaciones mucho más complejas en un abrir y cerrar de ojos. Exploremos algunas de estas operaciones.

Operaciones numéricas {#operaciones numéricas}

Antes de que podamos realizar cualquier operación NumPy, debemos instalar el paquete NumPy. Para instalar el paquete NumPy, puede usar el instalador pip. Ejecute el siguiente comando para instalar:

1
$ pip install numpy

De lo contrario, si está ejecutando Python a través de la distribución de Anaconda, puede ejecutar el siguiente comando en su lugar:

1
$ conda install numpy

Ahora que NumPy está instalado, veamos algunas de las operaciones más comunes de la biblioteca.

Creación de una matriz NumPy

Las matrices NumPy son los componentes básicos de la mayoría de las operaciones NumPy. Las matrices NumPy se pueden dividir en dos tipos: matrices unidimensionales y matrices bidimensionales.

Hay varias formas de crear una matriz NumPy. En esta sección, discutiremos algunos de ellos.

El método de matriz

Para crear una matriz NumPy unidimensional, simplemente podemos pasar una lista de Python al método array. Consulte el siguiente script para ver un ejemplo:

1
2
3
4
import numpy as np
x = [2, 3, 4, 5, 6]
nums = np.array([2, 3, 4, 5, 6])
type(nums)

En el script anterior, primero importamos la biblioteca NumPy como np y creamos una lista x. Luego pasamos esta lista a la función array de la biblioteca NumPy. Finalmente, imprimimos el tipo de matriz, lo que resultó en el siguiente resultado:

1
numpy.ndarray

Si imprimiera la matriz nums en la pantalla, la vería mostrada así:

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

Para crear una matriz bidimensional, puede pasar una lista de listas al método array como se muestra a continuación:

1
nums = np.array([[2,4,6], [8,10,12], [14,16,18]])

El script anterior da como resultado una matriz donde cada lista interna en la lista externa se convierte en una fila. El número de columnas es igual al número de elementos en cada lista interna. La matriz de salida se verá así:

1
2
3
array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])
El método arange

Otro método comúnmente utilizado para crear una matriz NumPy es el método arange. Este método toma el índice inicial de la matriz, el índice final y el tamaño del paso (que es opcional). Echa un vistazo al siguiente ejemplo:

1
nums = np.arange(2, 7)

Bastante simple, ¿verdad? El script anterior devolverá una matriz NumPy de tamaño 5 con los elementos 2, 3, 4, 5 y 6. Recuerde que el método arange devuelve una matriz que comienza con el índice inicial y termina en un índice menos que el final. índice. La salida de este código se ve así:

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

Ahora agreguemos un tamaño de paso de 2 a nuestra matriz y veamos qué sucede:

1
nums = np.arange(2, 7, 2)

La salida ahora se ve así:

1
array([2, 4, 6])

Puede ver que la matriz comienza en 2, seguida de un tamaño de paso de 2 y termina en 6, que es uno menos que el índice final.

El método de los ceros

Además de generar matrices personalizadas con sus datos precargados, también puede crear matrices NumPy con un conjunto de datos más simple. Por ejemplo, puede usar el método ceros para crear una matriz de ceros como se muestra a continuación:

1
zeros = np.zeros(5)

El script anterior devolverá una matriz unidimensional de 5 ceros. Imprime la matriz ceros y deberías ver lo siguiente:

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

De manera similar, para crear una matriz bidimensional, puede pasar el número de filas y columnas al método ceros, como se muestra a continuación:

1
zeros = np.zeros((5, 4))

El script anterior devolverá una matriz bidimensional de 5 filas y 4 columnas:

1
2
3
4
5
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
El método de las unidades

De manera similar, puede crear arreglos unidimensionales y bidimensionales de todos unos usando el método unos de la siguiente manera:

1
ones = np.ones(5)
1
array([1., 1., 1., 1., 1.])

Y nuevamente, para la matriz bidimensional, pruebe el siguiente código:

1
ones = np.ones((5, 4))

Ahora, si imprime la matriz unos en la pantalla, debería ver la siguiente matriz bidimensional:

1
2
3
4
5
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
El método linspace

Otro método muy útil para crear matrices NumPy es el método linspace. Este método toma tres argumentos: un índice inicial, un índice final y la cantidad de números espaciados linealmente que desea entre el rango especificado. Por ejemplo, si el primer índice es 1, el último índice es 10 y necesita 10 elementos igualmente espaciados dentro de este rango, puede usar el método linspace de la siguiente manera:

1
lin = np.linspace(1, 10, 10)

La salida devolverá números enteros del 1 al 10:

1
array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])

Ahora intentemos crear una matriz con 20 elementos espaciados linealmente entre 1 y 10. Ejecute el siguiente script:

1
lin = np.linspace(1, 10, 20)

Esto dará como resultado la siguiente matriz:

1
2
3
4
array([ 1.        ,  1.47368421,  1.94736842,  2.42105263,  2.89473684,
        3.36842105,  3.84210526,  4.31578947,  4.78947368,  5.26315789,
        5.73684211,  6.21052632,  6.68421053,  7.15789474,  7.63157895,
        8.10526316,  8.57894737,  9.05263158,  9.52631579, 10.        ])

Tenga en cuenta que la salida puede parecer una matriz, pero en realidad es una matriz unidimensional. Debido al problema de espaciado, los elementos se han mostrado en varias líneas.

El método del ojo

El método eye se puede usar para crear una matriz de identidad, que puede ser muy útil para realizar una variedad de operaciones en álgebra lineal. Una matriz identidad es una matriz con ceros en filas y columnas excepto en la diagonal. Los valores de la diagonal son todos unos. Vamos a crear una matriz de identidad de 4x4 usando el método eye:

1
idn = np.eye(4)

La matriz resultante se ve así:

1
2
3
4
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
El método aleatorio

Muchas veces necesitará crear matrices con números aleatorios. Puede usar la función rand del módulo random de NumPy para hacerlo. Aquí hay un ejemplo simple de la función rand:

1
random = np.random.rand(2, 3)

El script anterior devuelve una matriz de 2 filas y 3 columnas. La matriz contiene distribución uniforme de números entre 0 y 1:

1
2
array([[0.26818562, 0.65506793, 0.50035001],
       [0.527117  , 0.445688  , 0.99661   ]])

De manera similar, para crear una matriz de números aleatorios con la distribución gaussiana (o distribución "normal"), puede usar el método randn como mostrado a continuación:

1
random = np.random.randn(2, 3)

Finalmente, para crear una matriz de enteros aleatorios, existe el método randint para tal caso. El método randint toma el límite inferior, el límite superior y el número de enteros a devolver. Por ejemplo, si desea crear una matriz de 5 números enteros aleatorios entre 50 y 100, puede usar este método de la siguiente manera:

1
random = np.random.randint(50, 100, 5)

En nuestro caso, la salida se veía así:

1
array([54, 59, 84, 62, 74])

Es importante mencionar que estos números se generan aleatoriamente cada vez que llamas al método, por lo que verás números diferentes a los de nuestro ejemplo.

Vimos diferentes formas de crear matrices de Python. Exploremos ahora algunas de las otras funciones de matriz.

Remodelación de NumPy Array

Con NumPy puede convertir una matriz unidimensional en una matriz bidimensional utilizando el método reformar.

Primero vamos a crear una matriz de 16 elementos usando la función arange. Ejecuta el siguiente código:

1
nums = np.arange(1, 17)

La matriz nums es una matriz unidimensional de 16 elementos, que van del 1 al 16:

1
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])

Ahora vamos a convertirlo en una matriz bidimensional de 4 filas y 4 columnas:

1
nums2 = nums.reshape(4, 4)

La matriz ahora se ve así:

1
2
3
4
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

Es pertinente mencionar que no puede remodelar una matriz si el número de elementos en la matriz unidimensional no es igual al producto de filas y columnas de la matriz remodelada. Por ejemplo, si tiene 45 elementos en una matriz unidimensional, no puede remodelarla en una matriz de 5 filas y 10 columnas, ya que una matriz de 5x10 tiene 50 elementos y la original solo tiene 45.

Búsqueda de valores máximos y mínimos

Puede usar las funciones min/max para encontrar fácilmente el valor del número más pequeño y más grande en su matriz. Para nuestro ejemplo, primero creemos una matriz de 5 enteros aleatorios:

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

Nuestra matriz de enteros aleatorios se ve así:

1
[51 40 84 38  1]

Recuerde, estos números se generan aleatoriamente, por lo tanto, lo más probable es que tenga un conjunto diferente de números. Usemos las funciones min y max para encontrar los valores mínimo y máximo de la matriz que acabamos de crear. Para hacerlo, ejecute el siguiente código para encontrar el valor mínimo:

1
2
xmin = random.min()
print(xmin)

"1" se imprimirá en la salida.

Del mismo modo, para obtener el valor máximo, ejecute el siguiente código:

1
2
xmax = random.max()
print(xmax)

El script anterior devolverá "84" como salida.

También puede encontrar el índice de los valores máximo y mínimo usando las funciones argmax() y argmin(). Echa un vistazo al siguiente script:

1
print(random.argmax())

La secuencia de comandos anterior imprimirá "2" ya que 84 es el número más grande de la lista y se encuentra en la segunda posición de la matriz.

De manera similar, argmin() devolverá "4" porque 1 es el número más pequeño y está ubicado en la cuarta posición.

Indexación de matriz en NumPy

Para poder usar las matrices NumPy de manera efectiva, es muy importante comprender la forma en que se indexan las matrices, lo cual analizaré en las próximas secciones.

Indexación con matrices 1-D

Vamos a crear una matriz simple de 15 números:

1
nums = np.arange(1, 16)

Puede recuperar cualquier elemento pasando el número de índice. Al igual que las listas de Python, las matrices de NumPy tienen un índice cero. Por ejemplo, para encontrar el elemento en el segundo índice (tercera posición) de la matriz, puede usar la siguiente sintaxis:

1
print(nums[2])

Tenemos el dígito 3 en el segundo índice, por lo tanto, se imprimirá en la pantalla.

También puede imprimir un rango de números utilizando la indexación. Para obtener el rango, debe pasar el índice inicial y uno menos que el índice final, separados por dos puntos, dentro de los corchetes que siguen al nombre de la matriz. Por ejemplo, para obtener los elementos del primer al séptimo índice, puede usar la siguiente sintaxis:

1
print(nums[1:8])

El script anterior imprimirá los números enteros del 2 al 8:

1
[2 3 4 5 6 7 8]

Aquí, en la matriz nums, tenemos 2 en el índice 1 y 8 en el índice siete.

También puede dividir una matriz y asignar los elementos de la matriz dividida a una nueva matriz:

1
2
nums2 = nums[0:8]
print(nums2)

En el script anterior, cortamos la matriz nums extrayendo sus primeros 8 elementos. Los elementos resultantes se asignan a la matriz nums2. Luego imprimimos la matriz nums2 en la consola. La salida es una nueva matriz de los primeros 8 números:

1
[1 2 3 4 5 6 7 8]
Indexación con matrices 2-D

Indexar una matriz NumPy bidimensional es muy similar a indexar una matriz. Primero creemos una matriz NumPy bidimensional de 3x3. Para hacerlo, ejecute el siguiente código:

1
nums2d = np.array(([1,2,3],[4,5,6],[7,8,9]))

Ahora vamos a imprimirlo:

1
print(nums2d)
1
2
3
[[1 2 3]
 [4 5 6]
 [7 8 9]]

Al igual que las matrices 1-D, las matrices NumPy con dos dimensiones también siguen el índice de base cero, es decir, para acceder a los elementos en la primera fila, debe especificar 0 como índice de fila. De manera similar, para acceder a los elementos en la primera columna, también debe especificar 0 para el índice de la columna.

Recuperemos un elemento de la matriz nums2d, ubicado en la primera fila y la primera columna:

1
print(nums2d[0, 0])

Verá "1" en la salida. De manera similar, podemos recuperar el elemento en la tercera fila y la tercera columna de la siguiente manera:

1
print(nums2d[2, 2])

Verá "9" en la salida.

Además de extraer un solo elemento, puede extraer toda la fila pasando solo el índice de la fila a los corchetes. Por ejemplo, el siguiente script devuelve la primera fila de la matriz nums2d:

1
print(nums2d[0])

La salida es solo una matriz unidimensional:

1
[1 2 3]

De manera similar, para recuperar solo la primera columna, puede usar la siguiente sintaxis:

1
print(nums2d[:,0])

La salida es, nuevamente, una matriz, pero es una combinación de los primeros elementos de cada matriz de la matriz bidimensional:

1
[1 4 7]

Finalmente, para recuperar los elementos de las dos primeras filas y las dos primeras columnas, se puede usar la siguiente sintaxis:

1
print(nums2d[:2,:2])

El script anterior devuelve el siguiente resultado:

1
2
[[1 2]
 [4 5]]

Operaciones aritméticas con NumPy Arrays

Para los ejemplos de esta sección, usaremos la matriz nums que creamos en la última sección.

Primero agreguemos dos matrices juntas:

1
nums3 = nums + nums

Puede agregar dos matrices juntas con las mismas dimensiones. Por ejemplo, la matriz nums contenía 15 elementos, por lo que podemos agregarla a sí misma. Se agregarán los elementos en los índices correspondientes. Ahora, si imprime la matriz nums3, la salida se ve así:

1
[ 2  4  6  8 10 12 14 16 18 20 22 24 26 28 30]

Como puede ver, cada posición es la suma de los 2 elementos en esa posición en las matrices originales.

Si agrega una matriz con un valor escalar, el valor se agregará a cada elemento de la matriz. Agreguemos 10 a la matriz nums e imprimamos la matriz resultante en la consola. Así es como lo harías:

1
2
nums3 = nums + 10
print(nums3)

Y la matriz nums3 resultante se convierte en:

1
[11 12 13 14 15 16 17 18 19 20 21 22 23 24 25]

La resta, suma, multiplicación y división se pueden realizar de la misma manera.

Además de la aritmética simple, puede ejecutar funciones más complejas en las matrices Numpy, p. logaritmo, raíz cuadrada, exponencial, etc.

La función de registro

El siguiente código simplemente devuelve una matriz con el registro de todos los elementos en la matriz de entrada:

1
2
nums3 = np.log(nums)
print(nums3)

La salida se ve así:

1
2
3
[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947
 1.94591015 2.07944154 2.19722458 2.30258509 2.39789527 2.48490665
 2.56494936 2.63905733 2.7080502 ]
La función exp

El siguiente script devuelve una matriz con exponentes de todos los elementos en la matriz de entrada:

1
2
nums3 = np.exp(nums)
print(nums3)
1
2
3
4
[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03
 8.10308393e+03 2.20264658e+04 5.98741417e+04 1.62754791e+05
 4.42413392e+05 1.20260428e+06 3.26901737e+06]
La función sqrt

El siguiente script devuelve una matriz con las raíces cuadradas de todos los elementos de la matriz de entrada:

1
2
nums3 = np.sqrt(nums)
print(nums3)
1
2
3
[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974
 2.64575131 2.82842712 3.         3.16227766 3.31662479 3.46410162
 3.60555128 3.74165739 3.87298335]
La función sin

El siguiente script devuelve una matriz con el seno de todos los elementos en la matriz de entrada:

1
2
nums3 = np.sin(nums)
print(nums3)
1
2
3
[ 0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427 -0.2794155
  0.6569866   0.98935825  0.41211849 -0.54402111 -0.99999021 -0.53657292
  0.42016704  0.99060736  0.65028784]

Operaciones de álgebra lineal con matrices numéricas {#operaciones de álgebra lineal con matrices numéricas}

Una de las mayores ventajas de las matrices NumPy es su capacidad para realizar operaciones de álgebra lineal, como el producto escalar de vectores y el producto escalar de matrices, mucho más rápido que con las listas predeterminadas de Python.

Hallar el producto punto vectorial

Calcular el vector producto punto para los dos vectores se puede calcular multiplicando los elementos correspondientes de los dos vectores y luego sumando los resultados de los productos.

Vamos a crear dos vectores e intentar encontrar su producto escalar manualmente. Un vector en NumPy es básicamente una matriz unidimensional. Ejecute el siguiente script para crear nuestros vectores:

1
2
x = np.array([2,4])
y = np.array([1,3])

El producto escalar de los dos vectores anteriores es (2 x 1) + (4 x 3) = 14.

Encontremos el producto escalar sin usar la biblioteca NumPy. Ejecute el siguiente script para hacerlo:

1
2
3
4
5
dot_product = 0
for a,b in zip(x,y):
    dot_product += a * b

print(dot_product)

En el script anterior, simplemente recorrimos los elementos correspondientes en los vectores x e y, los multiplicamos y los sumamos a la suma anterior. Si ejecuta el script anterior, verá "14" impreso en la consola.

Ahora, veamos cómo podemos encontrar el producto escalar usando la biblioteca NumPy. Mira el siguiente guión:

1
2
a = x * y
print(a.sum())

Sabemos que si multiplicamos las dos matrices NumPy, los elementos correspondientes de ambas matrices se multiplican en función de su índice. En el script anterior, simplemente multiplicamos los vectores x e y. Luego llamamos al método sum en la matriz resultante, que suma todos los elementos de la matriz. El script anterior también devolverá "14" en la salida.

El método anterior es simple, sin embargo, la biblioteca NumPy hace que sea aún más fácil encontrar el producto punto a través del método punto, como se muestra aquí:

1
print(x.dot(y))

Para matrices muy grandes, también debería notar una mejora en la velocidad con respecto a nuestra versión solo de Python, gracias al uso de código C de NumPy para implementar muchas de sus funciones principales y estructuras de datos.

Multiplicación de matrices

Al igual que el producto escalar de dos vectores, también puedes multiplicar dos matrices. En NumPy, una matriz no es más que una matriz bidimensional. Para multiplicar dos matrices, las dimensiones internas de las matrices deben coincidir, lo que significa que el número de columnas de la matriz de la izquierda debe ser igual al número de filas de la matriz del lado derecho del producto. Por ejemplo, si una matriz X tiene dimensiones [3,4] y otra matriz Y tiene dimensiones [4,2], entonces las matrices X e Y se pueden multiplicar entre sí. La matriz resultante tendrá las dimensiones [3,2], que es el tamaño de las dimensiones exteriores.

Para multiplicar dos matrices, la función dot se puede usar como se muestra a continuación:

1
2
3
4
5
6
7
X = np.array(([1,2,3], [4,5,6]))

Y = np.array(([1,2], [4,5], [7,8]))

Z = np.dot(X, Y)

print(Z)

En el script anterior, creamos una matriz de 3x2 llamada X y una matriz de 2x3 llamada Y. Luego encontramos el producto escalar de las dos matrices y asignamos la matriz resultante a la variable Z. Finalmente, imprimimos la matriz resultante en la consola. En la salida, debería ver una matriz de 2x2 como se muestra a continuación:

1
2
[[30 36]
 [66 81]]

También puede multiplicar las dos matrices por elementos. Para hacerlo, las dimensiones de las dos matrices deben coincidir, al igual que cuando estábamos sumando matrices. La función multiply se utiliza para la multiplicación por elementos.

Intentemos multiplicar las matrices X e Y por elementos:

1
Z = np.multiply(X, Y)

El siguiente error ocurrirá cuando ejecute el código anterior:

1
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

El error ocurre debido a la falta de coincidencia entre las dimensiones de las matrices X e Y. Ahora, intentemos multiplicar la matriz X por sí misma usando la función multiply:

1
Z = np.multiply(X, X)

Ahora, si imprime la matriz Z, debería ver el siguiente resultado:

1
2
[[ 1  4  9]
 [16 25 36]]

La matriz X pudo multiplicarse con éxito porque las dimensiones de las matrices multiplicadas coincidían.

Hallar la inversa de una matriz

Otra operación matricial muy útil es encontrar la inversa de una matriz. La biblioteca NumPy contiene la función ìnv en el módulo linalg.

Para nuestro ejemplo, encontremos la inversa de una matriz de 2x2. Echa un vistazo al siguiente código:

1
2
3
Y = np.array(([1,2], [3,4]))
Z = np.linalg.inv(Y)
print(Z)

La salida del código anterior se ve así:

1
2
[[-2.   1. ]
 [ 1.5 -0.5]]

Ahora, para verificar si la inversa se ha calculado correctamente, podemos tomar el producto escalar de una matriz con su inversa, lo que debería dar como resultado una matriz identidad.

1
2
W = Y.dot(Z)
print(W)
1
2
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]

Y el resultado fue el que esperábamos. Unos en la diagonal y ceros (o muy cerca de cero) en otros lugares.

Hallar el determinante de una matriz

El determinante de una matriz se puede calcular usando el método det, que se muestra aquí:

1
2
3
4
5
X = np.array(([1,2,3], [4,5,6], [7,8,9]))

Z = np.linalg.det(X)

print(Z)

En el script anterior, creamos una matriz de 3x3 y encontramos su determinante usando el método det. En la salida, debería ver "6.66133814775094e-16".

Hallar el rastro de una matriz

La traza de una matriz es la suma de todos los elementos de la diagonal de una matriz. La biblioteca NumPy contiene la función trace que se puede usar para encontrar la traza de una matriz. Mira el siguiente ejemplo:

1
2
3
4
5
X = np.array(([1,2,3], [4,5,6], [7,8,9]))

Z = np.trace(X)

print(Z)

En la salida, debería ver "15", ya que la suma de los elementos diagonales de la matriz X es 1 + 5 + 9 = 15.

Conclusión

La biblioteca Pythons NumPy es una de las bibliotecas más populares para computación numérica. En este artículo, exploramos la biblioteca NumPy en detalle con la ayuda de varios ejemplos. También mostramos cómo realizar diferentes operaciones de álgebra lineal a través de la biblioteca NumPy, que se usan comúnmente en muchas aplicaciones de ciencia de datos.

Si bien cubrimos un poco de la funcionalidad principal de NumPy, todavía queda mucho por aprender. Si quieres aprender más, te sugiero que pruebes un curso como [Ciencia de datos en Python, Pandas, Scikit-learn, Numpy, Matplotlib](https://stackabu.se/data-science-python- pandas-sklearn-numpy), que cubre NumPy, Pandas, Scikit-learn y Matplotlib con mucha más profundidad de lo que pudimos cubrir aquí.

Te sugiero que practiques los ejemplos de este artículo. Si planea comenzar una carrera como científico de datos, la biblioteca NumPy es definitivamente una de las herramientas que debe aprender para ser un miembro exitoso y productivo del campo.