NumPy Tutorial: Una guía simple basada en ejemplos

Introducción

La biblioteca NumPy es una popular biblioteca de Python utilizada para aplicaciones de computación científica, 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 matemáticas y lógicas, 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 las 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 Python gracias a su uso intensivo de las 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 Python tomaría un poco de código personalizado.
Con respecto al último punto, eche un vistazo a la siguiente secuencia de comandos:
x = [2, 3, 4, 5, 6]  
y = [a + 2 for a in x]  
Aquí, para agregar 2 a cada elemento de la lista x, tenemos que recorrer la lista completa y agregar 2 a cada elemento individualmente. Ahora veamos cómo podemos realizar la misma tarea con la biblioteca NumPy:
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 que también es 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. Vamos a explorar algunas de estas operaciones.

Operaciones NumPy

Antes de que podamos realizar cualquier operación NumPy, necesitamos instalar el paquete NumPy. Para instalar el paquete NumPy, puede usar el instalador pip. Ejecute el siguiente comando para instalar:
$ pip install numpy
De lo contrario, si está ejecutando Python a través de la distribución de Anaconda, puede ejecutar el siguiente comando:
$ conda install numpy
Ahora que NumPy está instalado, veamos algunas de las operaciones más comunes de la biblioteca.

Creando 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 arraymétodo. Echa un vistazo a la siguiente secuencia de comandos para ver un ejemplo:
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 npy creamos una lista xLuego pasamos esta lista a la arrayfunción de la biblioteca NumPy. Finalmente, imprimimos el tipo de la matriz, que resultó en el siguiente resultado:
numpy.ndarray  
Si imprimiera la numsmatriz en la pantalla, vería que se muestra así:
array([2, 3, 4, 5, 6])  
Para crear una matriz bidimensional, puede pasar una lista de listas al arraymétodo como se muestra a continuación:
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í:
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 arangemétodo. Este método toma el índice de inicio de la matriz, el índice final y el tamaño del paso (que es opcional). Echa un vistazo al siguiente ejemplo:
nums = np.arange(2, 7)  
Bastante simple, ¿verdad? La secuencia de comandos anterior devolverá una matriz NumPy de tamaño 5 con los elementos 2, 3, 4, 5 y 6. Recuerde que el arangemétodo devuelve una matriz que comienza con el índice inicial y termina en un índice menos que el índice final. La salida de este código se ve así:
array([2, 3, 4, 5, 6])  
Ahora agreguemos un tamaño de paso de 2 a nuestra matriz y veamos qué sucede:
nums = np.arange(2, 7, 2)  
La salida ahora se ve así:
array([2, 4, 6])  
Puede ver que la matriz comienza en 2, seguido 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 arreglos personalizados con sus datos precargados, también puede crear arreglos NumPy con un conjunto de datos más simple. Por ejemplo, puede usar el zerosmétodo para crear una matriz de todos los ceros como se muestra a continuación:
zeros = np.zeros(5)  
El script anterior devolverá una matriz unidimensional de 5 ceros. Imprima la zerosmatriz y debería ver lo siguiente:
array([0., 0., 0., 0., 0.])  
De manera similar, para crear una matriz bidimensional, puede pasar el número de filas y columnas al zerosmétodo, como se muestra a continuación:
zeros = np.zeros((5, 4))  
La secuencia de comandos anterior devolverá una matriz bidimensional de 5 filas y 4 columnas:
array([[0., 0., 0., 0.],  
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
El metodo de los
De manera similar, puede crear matrices unidimensionales y bidimensionales de todas las unidades utilizando el onesmétodo de la siguiente manera:
ones = np.ones(5)  
array([1., 1., 1., 1., 1.])  
Y nuevamente, para la matriz bidimensional, pruebe el siguiente código:
ones = np.ones((5, 4))  
Ahora, si imprime la onesmatriz en la pantalla, debería ver la siguiente matriz bidimensional:
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
El metodo del linspace
Otro método muy útil para crear matrices NumPy es el linspacemétodo. Este método toma tres argumentos: un índice de inicio, un índice final y el número 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 linspacemétodo de la siguiente manera:
lin = np.linspace(1, 10, 10)  
La salida devolverá enteros de 1 a 10:
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:
lin = np.linspace(1, 10, 20)  
Esto resultará en la siguiente matriz:
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.        ])
Observe 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 metodo de ojo
El eyemétodo 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 de identidad es una matriz con ceros a través de filas y columnas, excepto la diagonal. Los valores diagonales son todos unos. Vamos a crear una matriz de identidad 4x4 utilizando el eyemétodo:
idn = np.eye(4)  
La matriz resultante se ve así:
array([[1., 0., 0., 0.],  
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
El método aleatorio
Muchas veces necesitarás crear matrices con números aleatorios. Puedes usar la randfunción del randommódulo de NumPy para hacerlo. Aquí hay un ejemplo simple de la randfunción:
random = np.random.rand(2, 3)  
El script anterior devuelve una matriz de 2 filas y 3 columnas. La matriz contiene una distribución uniforme de números entre 0 y 1:
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 randnmétodo como se muestra a continuación:
random = np.random.randn(2, 3)  
Finalmente, para crear una matriz de enteros aleatorios, randintexiste el método para tal caso. El randintmétodo 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 enteros aleatorios entre 50 y 100, puede usar este método de la siguiente manera:
random = np.random.randint(50, 100, 5)  
En nuestro caso, la salida se veía así:
array([54, 59, 84, 62, 74])  
Es importante mencionar que estos números se generan aleatoriamente cada vez que llama al método, por lo que verá números diferentes a los de nuestro ejemplo.
Vimos diferentes formas de crear matrices de Python. Ahora exploremos algunas de las otras funciones de matriz.

Remodelando NumPy Array

Usando NumPy puedes convertir una matriz unidimensional en una matriz bidimensional usando el reshapemétodo.
Primero creamos una matriz de 16 elementos usando la arangefunción. Ejecuta el siguiente código:
nums = np.arange(1, 17)  
La numsmatriz es una matriz unidimensional de 16 elementos, que van desde 1 a 16:
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])  
Nos conviertanlo en una matriz bidimensional de 4 filas y 4 columnas:
nums2 = nums.reshape(4, 4)  
La matriz ahora se ve así:
array([[ 1,  2,  3,  4],  
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])
Es pertinente mencionar que no puede reformar una matriz si el número de elementos de la matriz unidimensional no es igual al producto de las filas y columnas de la matriz reformada. Por ejemplo, si tiene 45 elementos en una matriz 1-d, no puede reformularlo en una matriz de 5 filas y 10 columnas, ya que una matriz de 5x10 tiene 50 elementos y la original solo tiene 45.

Encontrar valores máximos / mínimos

Puede usar minmaxfunciones para encontrar fácilmente el valor del número más pequeño y más grande en su matriz. Para nuestro ejemplo, primero creamos una matriz de 5 enteros aleatorios:
random = np.random.randint(1, 100, 5)  
print(random)  
Nuestra matriz de enteros aleatorios se ve así:
[51 40 84 38  1]
Recuerde, estos números se generan de forma aleatoria, por lo tanto, lo más probable es que tenga un conjunto diferente de números. Usemos minmaxfunciones para encontrar los valores mínimos y máximos de la matriz que acabamos de crear. Para hacerlo, ejecute el siguiente código para encontrar el valor mínimo:
xmin = random.min()  
print(xmin)  
"1" se imprimirá en la salida.
Del mismo modo, para valor máximo, ejecute el siguiente código:
xmax = random.max()  
print(xmax)  
La secuencia de comandos anterior devolverá "84" como salida.
También puede encontrar el índice de los valores máximo y mínimo utilizando las funciones argmax()argmin()Echa un vistazo a la siguiente secuencia de comandos:
print(random.argmax())  
El script anterior imprimirá "2" ya que 84 es el número más grande en 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 4ª posición.

Indización de matrices en NumPy

Para utilizar efectivamente las matrices NumPy, es muy importante entender la forma en que se indexan las matrices, lo cual trataré en las siguientes secciones.
Indexación con matrices 1-D
Vamos a crear una matriz simple de 15 números:
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 están indexadas en cero. Por ejemplo, para encontrar el elemento en el segundo índice (tercera posición) de la matriz, puede usar la siguiente sintaxis:
print(nums[2])  
Tenemos el dígito 3 en el segundo índice, por lo que 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 de inicio 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:
print(nums[1:8])  
El script anterior imprimirá los enteros de 2 a 8:
[2 3 4 5 6 7 8]
Aquí en la numsmatriz, 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 segmentada a una nueva matriz:
nums2 = nums[0:8]  
print(nums2)  
En el script anterior, dividimos la numsmatriz extrayendo sus primeros 8 elementos. Los elementos resultantes se asignan a la nums2matriz. Luego imprimimos la nums2matriz en la consola. La salida es una nueva matriz de los primeros 8 números:
[1 2 3 4 5 6 7 8]
Indexación con matrices 2-D
La indexación de una matriz NumPy bidimensional es muy similar a la indexación de una matriz. Primero vamos a crear una matriz numPy bidimensional de 3x3. Para ello, ejecute el siguiente código:
nums2d = np.array(([1,2,3],[4,5,6],[7,8,9]))  
Ahora vamos a imprimirlo:
print(nums2d)  
[[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 de la primera fila, debe especificar 0 como el índice de la fila. Al igual que para acceder a los elementos de la primera columna, también debe especificar 0 para el índice de la columna.
Recuperemos un elemento de la nums2dmatriz, ubicado en la primera fila y la primera columna:
print(nums2d[0, 0])  
Verás "1" en la salida. Del mismo modo, podemos recuperar el elemento en la tercera fila y la tercera columna de la siguiente manera:
print(nums2d[2, 2])  
Verás "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, la siguiente secuencia de comandos devuelve la primera fila de la nums2dmatriz:
print(nums2d[0])  
La salida solo una matriz unidimensional:
[1 2 3]
De forma similar, para recuperar solo la primera columna, puede utilizar la siguiente sintaxis:
print(nums2d[:,0])  
La salida es, una vez más, una matriz, pero es una combinación de los primeros elementos de cada matriz de la matriz bidimensional:
[1 4 7]
Finalmente, para recuperar los elementos de las dos primeras filas y las dos primeras columnas, se puede usar la siguiente sintaxis:
print(nums2d[:2,:2])  
El script anterior devuelve el siguiente resultado:
[[1 2]
 [4 5]]

Operaciones aritméticas con matrices NumPy

Para los ejemplos en esta sección, usaremos la numsmatriz que creamos en la última sección.
Primero agreguemos dos matrices juntas:
nums3 = nums + nums  
Puede agregar dos matrices juntas con las mismas dimensiones. Por ejemplo, la numsmatriz contenía 15 elementos, por lo tanto, podemos agregarla a sí misma. Se añadirán los elementos en los índices correspondientes. Ahora, si imprime la nums3matriz, la salida se ve así:
[ 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 numsmatriz e imprimamos la matriz resultante en la consola. Así es como lo harías:
nums3 = nums + 10  
print(nums3)  
Y la nums3matriz resultante se convierte en:
[11 12 13 14 15 16 17 18 19 20 21 22 23 24 25]
La resta, la suma, la multiplicación y la 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 de Numpy, por ejemplo, log, 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:
nums3 = np.log(nums)  
print(nums3)  
La salida se ve así:
[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
La siguiente secuencia de comandos devuelve una matriz con exponentes de todos los elementos en la matriz de entrada:
nums3 = np.exp(nums)  
print(nums3)  
[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
La siguiente secuencia de comandos devuelve una matriz con las raíces cuadradas de todos los elementos de la matriz de entrada:
nums3 = np.sqrt(nums)  
print(nums3)  
[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 funcion del pecado
La siguiente secuencia de comandos devuelve una matriz con el seno de todos los elementos de la matriz de entrada:
nums3 = np.sin(nums)  
print(nums3)  
[ 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 NumPy

Una de las mayores ventajas de los arreglos NumPy es su capacidad para realizar operaciones de álgebra lineal, como el producto vectorial de puntos y el producto de matriz de puntos, mucho más rápido que con las listas predeterminadas de Python.
Encontrar el producto Vector Dot
El cálculo del producto de punto vectorial para los dos vectores se puede calcular multiplicando los elementos correspondientes de los dos vectores y luego agregando los resultados de los productos.
Vamos a crear dos vectores e intentar encontrar su producto de punto manualmente. Un vector en NumPy es básicamente una matriz unidimensional. Ejecuta el siguiente script para crear nuestros vectores:
x = np.array([2,4])  
y = np.array([1,3])  
El producto puntual de los dos vectores anteriores es (2 x 1) + (4 x 3) = 14.
Encontremos el producto punto sin usar la biblioteca NumPy. Ejecute el siguiente script para hacerlo:
dot_product = 0  
for a,b in zip(x,y):  
    dot_product += a * b

print(dot_product)  
En el script anterior, simplemente hicimos un bucle a través de los elementos xyvectores correspondientes, los multiplicamos y los agregamos a la suma anterior. Si ejecuta la secuencia de comandos anterior, verá "14" impreso en la consola.
Ahora, veamos cómo podemos encontrar el producto de puntos utilizando la biblioteca NumPy. Mira el siguiente script:
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 xyLuego llamamos al summétodo 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 dotmétodo, como se muestra aquí:
print(x.dot(y))  
Para arrays muy grandes, también debería notar una mejora en la velocidad con respecto a nuestra versión exclusiva de Python, gracias al uso del 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 de puntos 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 en el lado derecho del producto. Por ejemplo, si una matriz X tiene dimensiones [3,4] y otra matriz Y tiene dimensiones de [4,2], entonces las matrices X e Y se pueden multiplicar. La matriz resultante tendrá las dimensiones [3,2], que es el tamaño de las dimensiones exteriores.
Para multiplicar dos matrices, la dotfunción se puede utilizar como se muestra a continuación:
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 Xy una matriz de 2x3 llamada YLuego encontramos el producto puntual de las dos matrices y asignamos la matriz resultante a la variable ZFinalmente, imprimimos la matriz resultante en la consola. En la salida debería ver una matriz de 2x2 como se muestra a continuación:
[[30 36]
 [66 81]]
También puedes multiplicar las dos matrices de forma elemental. Para hacerlo, las dimensiones de las dos matrices deben coincidir, al igual que cuando agregábamos matrices juntas. La multiplyfunción se utiliza para la multiplicación de elementos.
Intentemos multiplicar las matrices Xy los Yelementos:
Z = np.multiply(X, Y)  
El siguiente error ocurrirá cuando ejecute el código anterior:
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)  
El error se produce debido a la falta de coincidencia entre las dimensiones de las matrices XYAhora, intentemos multiplicar la Xmatriz utilizando la multiplyfunción:
Z = np.multiply(X, X)  
Ahora, si imprime la Zmatriz, debería ver el siguiente resultado:
[[ 1  4  9]
 [16 25 36]]
La Xmatriz pudo multiplicarse exitosamente consigo misma porque las dimensiones de las matrices multiplicadas coincidían.
Encontrando lo inverso de una matriz
Otra operación de matriz muy útil es encontrar el inverso de una matriz. La biblioteca NumPy contiene la ìnvfunción en el linalgmódulo.
Para nuestro ejemplo, encontremos la inversa de una matriz de 2x2. Echa un vistazo al siguiente código:
Y = np.array(([1,2], [3,4]))  
Z = np.linalg.inv(Y)  
print(Z)  
La salida del código anterior se ve así:
[[-2.   1. ]
 [ 1.5 -0.5]]
Ahora, para verificar si el inverso se ha calculado correctamente, podemos tomar el producto puntual de una matriz con su inverso, que debería producir una matriz de identidad.
W = Y.dot(Z)  
print(W)  
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]
Y el resultado fue como esperábamos. Unos en la diagonal y ceros (o muy cerca de cero) en otros lugares.
Encontrar el determinante de una matriz
El determinante de una matriz se puede calcular utilizando el detmétodo, que se muestra aquí:
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 detmétodo. En la salida, debería ver "6.66133814775094e-16".
Encontrar el rastro de una matriz
La traza de una matriz es la suma de todos los elementos en la diagonal de una matriz. La biblioteca NumPy contiene una tracefunción que se puede usar para encontrar la traza de una matriz. Mira el siguiente ejemplo:
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 Xes 1 + 5 + 9 = 15.

Conclusión

Pythons NumPy library es una de las bibliotecas más populares para la 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 utilizan comúnmente en muchas aplicaciones de ciencia de datos.
Si bien cubrimos un poco la funcionalidad principal de NumPy, todavía queda mucho por aprender. Si desea obtener más información, le sugiero que pruebe un curso como Data Science en Python, Pandas, Scikit-learn, Numpy, Matplotlib , que cubre NumPy, Pandas, Scikit-learn y Matplotlib con mucha más profundidad de lo que Pudimos cubrir aquí.
Le sugiero que practique los ejemplos en este artículo. Si está planeando comenzar una carrera como científico de datos, la biblioteca NumPy es definitivamente una de las herramientas que necesita para aprender a ser un miembro exitoso y productivo del campo.

Acerca de: Programator

Somos Instinto Programador

0 comentarios:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Con tecnología de Blogger.