Tutorial de NumPy: Una guía sencilla basada en ejemplos

    Introducción

    La biblioteca NumPy es una biblioteca de Python popular 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: Transformada 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 funciones matemáticas centrales de Python, algunas de las cuales se describen aquí:

    • NumPy es extremadamente rápido en comparación con el núcleo de Python gracias a su uso intensivo de extensiones C.
    • 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.
    • NumPy viene con una variedad de funcionalidades integradas, que en el núcleo de Python requerirían un poco de código personalizado.

    Respecto al último punto, echa un vistazo al siguiente guión:

    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 toda la lista 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 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 NumPy

    Antes de que podamos realizar cualquier operación de 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 Anaconda, puede ejecutar el siguiente comando en su lugar:

    $ 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. Consulte el siguiente script 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 como npy creamos una lista x. Luego pasamos esta lista a la arrayfunción de la biblioteca NumPy. Finalmente, imprimimos el tipo de matriz, lo que resultó en la siguiente salida:

    numpy.ndarray
    

    Si numstuviera que imprimir la matriz en la pantalla, la verá mostrada 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 de 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 de finalización y el tamaño del paso (que es opcional). Eche un vistazo al siguiente ejemplo:

    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 arangemétodo devuelve una matriz que comienza con el índice inicial y termina en un índice menor 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, 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 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 tanto el número de filas como de columnas al zerosmétodo, como se muestra a continuación:

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

    El script 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 método de los

    Del mismo modo, puede crear matrices unidimensionales y bidimensionales de todos unos 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 método linspace

    Otro método muy útil para crear matrices NumPy es el linspacemétodo. 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 linspacemétodo de la siguiente manera:

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

    La salida devolverá números enteros del 1 al 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 dará como resultado 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.        ])
    

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

    El método del ojo

    El eyemétodo se puede utilizar 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 en filas y columnas excepto en la diagonal. Los valores diagonales son todos unos. Creemos una matriz de identidad 4×4 usando 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

    A menudo, necesitará crear matrices con números aleatorios. Puede 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   ]])
    

    Del mismo modo, para crear una matriz de números aleatorios con la distribución gaussiana (o distribución “normal”), puede utilizar el randnmétodo que se muestra a continuación:

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

    Finalmente, para crear una matriz de números enteros aleatorios, el randintmétodo existe 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 números 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 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. Exploremos ahora algunas de las otras funciones de matriz.

    Remodelación de la matriz NumPy

    Usando NumPy puedes convertir una matriz unidimensional en una matriz bidimensional usando el reshapemétodo.

    Primero creemos una matriz de 16 elementos usando la arangefunción. Ejecute el siguiente código:

    nums = np.arange(1, 17)
    

    La numsmatriz es una matriz unidimensional de 16 elementos, que van de 1 a 16:

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

    No, vamos a convertirlo 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 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 1-d, no puede remodelarla en una matriz de 5 filas y 10 columnas, ya que una matriz de 5×10 tiene 50 elementos y la original solo tiene 45.

    Encontrar valores máximos / mínimos

    Puede usar min/ maxfunctions 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:

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

    Nuestra matriz de números enteros aleatorios se ve así:

    [51 40 84 38  1]
    

    Recuerde, estos números se generan aleatoriamente, por lo tanto, lo más probable es que tenga un conjunto de números diferente. Usemos las funciones miny maxpara 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:

    xmin = random.min()
    print(xmin)
    

    Se imprimirá “1” en la salida.

    Del mismo modo, para obtener el 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 usando las funciones argmax()y argmin(). Eche un vistazo al siguiente guión:

    print(random.argmax())
    

    La secuencia de comandos anterior imprimirá “2” ya que 84 es el número más grande en la lista y está ubicado 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 matrices en NumPy

    Con el fin de utilizar eficazmente las matrices NumPy, es muy importante comprender la forma en que se indexan las matrices, que analizaré en las próximas secciones.

    Indexación con matrices 1-D

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

    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 mediante 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 utilizar la siguiente sintaxis:

    print(nums[1:8])
    

    El script anterior imprimirá los números enteros del 2 al 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 dividida a una nueva matriz:

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

    En el script anterior, cortamos 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

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

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

    Ahora imprimámoslo:

    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 índice de fila. De manera similar, 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á “1” en la salida. De manera similar, podemos recuperar el elemento en la tercera fila y tercera columna de la siguiente manera:

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

    print(nums2d[0])
    

    La salida es solo una matriz unidimensional:

    [1 2 3]
    

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

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

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

    print(nums2d[:2,:2])
    

    El script anterior devuelve la siguiente salida:

    [[1 2]
     [4 5]]
    

    Operaciones aritméticas con matrices NumPy

    Para los ejemplos de 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 que podemos agregarla a sí misma. Se agregará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 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

    El siguiente script devuelve una matriz con exponentes de todos los elementos de 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

    El siguiente script 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 función pecado

    El siguiente script devuelve una matriz con el seno de todos los elementos en 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 las matrices NumPy es su capacidad para realizar operaciones de álgebra lineal, como el producto escalar vectorial y el producto escalar de la matriz, mucho más rápido que con las listas predeterminadas de Python.

    Encontrar el producto de puntos vectoriales

    El cálculo del producto escalar vectorial para los dos vectores se puede calcular multiplicando los elementos correspondientes de los dos vectores y luego sumando los resultados de los productos.

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

    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.

    Busquemos el producto escalar 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 recorrimos los elementos correspondientes en xy los yvectores, los multiplicamos y los agregamos 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:

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

    Sabemos que si multiplicamos las dos matrices NumPy, los elementos correspondientes de ambas matrices se multiplican según su índice. En el script anterior, simplemente multiplicamos los vectores xy y. Luego 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 escalar a través del dotmétodo, como se muestra aquí:

    print(x.dot(y))
    

    Para arreglos 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 por parte de NumPy para implementar muchas de sus funciones centrales y estructuras de datos.

    Multiplicación de matrices

    Como el producto escalar de dos vectores, también puede 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 de [4,2], entonces las matrices X e Y se pueden multiplicar juntas. 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 3×2 con el nombre Xy una matriz de 2×3 con el nombre 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 2×2 como se muestra a continuación:

    [[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 multiplyfunción se utiliza para la multiplicación por elementos.

    Intentemos multiplicar las matrices Xy los Yelementos:

    Z = np.multiply(X, Y)
    

    Se producirá el siguiente error cuando ejecute el código anterior:

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

    El error se produce debido al desajuste entre las dimensiones de las matrices Xy Y. Ahora, intentemos multiplicar la Xmatriz consigo misma usando 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 con éxito consigo misma porque las dimensiones de las matrices multiplicadas coincidían.

    Encontrar la inversa de una matriz

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

    Para nuestro ejemplo, encontremos la inversa de una matriz de 2×2. Eche 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 la inversa se ha calculado correctamente, podemos tomar el producto escalar de una matriz con su inversa, lo que debería producir una matriz identidad.

    W = Y.dot(Z)
    print(W)
    
    [[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.

    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 3×3 y encontramos su determinante usando el detmétodo. En el resultado, debería ver “6.66133814775094e-16”.

    Encontrar 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 una tracefunción que se puede usar para encontrar el rastro 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

    La biblioteca Pythons NumPy 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 usan comúnmente en muchas aplicaciones de ciencia de datos.

    Si bien cubrimos bastante de la funcionalidad principal de NumPy, todavía hay mucho que 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 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 necesitar para aprender a ser un miembro exitoso y productivo del campo.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *