El uso de NumPy.

Es  una de las librerías  de Python  mas conocida, debido  a la fortaleza que da al lenguaje en el procesamiento de matrices y arrays de diferente complejidad.

Su uso, es ampliamente reconocido como procesador de cálculos científicos, (que entre otras muchas opciones permite procesar matrices multidimensionales, ejecutar funciones de transmisión o de Algebra Lineal, integrar scripts de otros lenguajes  como C y Fortran y  trabajar con números aleatorios ), también es utilizado a menudo para almacenar datos genéricos, con la propiedad de que podemos definir tipos de datos arbitrarios, que pueden integrarse  con múltiples tipos de bases de datos.  

Recordando que en Python todo es un objeto, diremos que NumPy establece entonces un arreglo multidimensional y otras matrices derivadas, que no son más que otros  objetos.

 Lo que hace Numpy,  es dotarnos una herramienta que nos permite realizar operaciones en un arreglo de cualquier dimensión.

Python ofrece otras opciones para procesar  datos,  como  son sus listas, la diferencia es que Numpy permite realizar operaciones estadísticas y de álgebra, crear  funciones de entrada y salida de datos, ordenar los integrantes de un arreglo y ejecutar operaciones lógicas, extendiendo la capacidad de Python para procesar matrices e información científica

A continuación mostrar algunos de los comandos más usados de esta extensión:

 Para instalar NumPy, en  Windows necesitas Python y Pip en tu sistema.

pip install numpy

#Luego importar la librería con Import

import numpy

Array()

Una lista de python no es un arreglo, sino elementos que se encuentran encerrados entre encerrados entre corchetes, para convertirlos en un array de Numpy, basta con aplicar la siguiente sintaxis:

elementoLista = numpy.array

 import numpy
 l = [1, 2, 3, 4, 5]
 nuevo = numpy.array(l)
 print("la lista convertida a array es = ", nuevo) 

y obtenemos el nuevo array:

>>la lista convertida a array
es =  [1 2 3 4 5]

Del mismo modo haríamos si en vez de ser una lista es una tupla. Sabemos que la tupla contiene una serie de elementos encerrados entre paréntesis, entonces será:

 import numpy
 tupla = (1, 2, 3, 4, 5)
 nuevoarray = numpy.array(tupla)
 print("El nuevo array a partir de la tupla es  = ", nuevoarray) 

La salida será:

>>El nuevo array a partir de
la tupla es  =  [1 2 3 4 5]

Append()

numpy.append(array, value, axis)

append() añade los elementos al final del arreglo, ya sean columnas o valores independientes, por lo que se obtiene entonces un nuevo array actualizado.

Si no definimos el valor de axis(es opcional y asimila valores enteros),  la nueva matriz obtenida se aplanará.

Para añadir una columna lo haríamos de este modo: Considere el siguiente ejemplo donde creamos un arreglo bidimensional e insertamos dos columnas:

 import numpy
 uno = numpy.array([[0, 1, 2, 3,], [4, 5, 6, 8,]])
 dos = numpy.array([[7], [9]])
 nuevo = numpy.append(uno, dos, axis = 1)
 print(nuevo) 

eso nos dará como resultado:

 [[0,1,2,3,7],
 [4,5,6,8,9]] 

Si no usaramos un valor para axis

newArray = numpy.append(a, b)

El resultado seria

 [0, 1,2, 3, 4, 5, 6, 8, 7, 9]

Añadir una fila

 import numpy
 a1 = numpy.array([[0, 1, 2, 3], [4, 5, 6, 7]])
 nuevo = numpy.append(a1, [[8, 9, 10, 11, 12]], axis = 0)
 print(nuevo)
 [[0, 1, 2, 3]
 [, 5, 6, 7]
 [8, 9, 10, 11, 12]] 

Añadir un arreglo a otro

 import numpy
 x = numpy.array([8, 12, 16, 20, 24])
 y = numpy.array([28, 32, 36, 40, 44])
 nuevo = numpy.append(x, y)
 print("Nuevo array resultante = ", nuevo) 

el resultado es:

Nuevo array resultante =  [ 8 12 16 20 24 28 32 36 40 44]

Insert()

La diferencia con append(), es que insert(), permite decidir donde exactamente queremos agregar el elemento,  seleccionando el índice que deseamos.

 import numpy
 ar = numpy.array([0, 1, 2,3])#declaramos el array tipo numpy
 nuevo = numpy.insert(a, 2, 55)#insertamos en el índice 2 el valor 55
 print(nuevo) 

La salida será la siguiente:

[0, 1, 55, 2, 3]

delete()

Se utiliza para  eliminar un elemento de un arreglo NumPy  

 import numpy
 restar = numpy.array([1, 2, 3, 4, 5])
 nuevo = numpy.delete(restar, 2, axis = 0)
 print(nuevo) 

Obtendremos:

[1 2 4 5]

Eliminar una fila

import numpy
valores = numpy.array([[1, 2, 3, 4, 5], [6, 7, 8, 9,10], [11, 12, 25, 22]])
nuevo = numpy.delete(valores, 1, axis = 0)
print(nuevo) 

 esto nos dara como resultado:

[list([1, 2, 3, 4, 5]) list([11, 12, 25, 22])]

Size

El método size tiene diferentes usos, como obtener el número de elementos  en un array o calcular la longitud de este:

Calcular el número de elementos en un array

 import numpy
 ar = numpy.array([1000, 2000, 3000, 6000])
 if(ar.size != 0):
     print("la matriz no esta vacia")
 else:
     print("ar contiene = ", ar) 

La salida es la siguiente:

>>la matriz no esta vacia

 Si moficaramos  el código y colocaramos

 import numpy
 ar = numpy.array([1000, 2000, 3000, 6000])
 if(ar.size == 0):
     print("la matriz no esta vacia")
 else:
     print("ar contiene = ", ar) 

Obtendriamos

>>ar contiene =  [1000 2000 3000 6000]

where()

Nos devuelve el índice de un valor

 import numpy
 lista = numpy.array(['a', 2, 'b', 4, 'c'])
 print("c is found at index: ", index[0]) 

El resultado será:

>>c is found at index:  (array([4]),)

Si cambiamos la última línea de nuestro código

 import numpy
 lista = numpy.array(['a', 2, 'b', 4, 'c'])
 print("c is found at index: ", numpy.where(lista == '5')) 

Obtendremos también el tipo de dato

>>c is found at index:  (array([], dtype=int64),)

Obtener la longitud de un array

 import numpy
 cuerpo = numpy.array([1, 2, 3, 4, 5, 6])
 print("El tamaño del cuerpo  = ", cuerpo.size) 

 el resultado será:

>>El tamaño del cuerpo  =  6

Dividir un arreglo

Para dividir un arreglo utilizaremos dos puntos (:) y la sintaxis es la siguiente :

array[from:to]

 Funciona de este modo:

 import numpy
 parte = numpy.array([1, 2, 3, 4, 5, 6, 7, 8])
 print("Un pedazo del array parte es = ", parte[2:5]) 

Obtendremos:

>>un pedazo del array parte es
=  [3 4 5]

Lo que hemos hecho ha sido extraer del arreglo parte una sección del mismo que va del índice 2 al 5.

 Extraer los dos últimos elementos

 import numpy
 two_last= numpy.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
 print("A subset of array a = ", two_last[-2:]) 

Resultado:

>>A subset of array a =  [7 8]

addition()  

Numpy, también permite aplicar funciones a los miembros de un arreglo o matriz multidimensional, mediante el uso de addition()

 import numpy
 addition = lambda x: (x + x*2)
 conjunto = numpy.array([1, 2, 3, 4, 5, 6])
 print("Resultado: ", addition(conjunto)) 

La salida es:

Resultado:  [ 3 6  9 12 15 18]

tolist

El método tolist, nos permitirá convertir un arreglo en una lista.

 import numpy
 x = numpy.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
 print("Convirtiendo un array en lista = ", x.tolist()) 

obtenemos entonces:

>>Convirtiendo un array en lista =  [10, 20, 30, 40, 50, 60, 70, 80,90]

savetxt()

Con savetxt(), podemos exportar un arreglo a formato de texto o csv: 

 import numpy
 a = numpy.array([16, 32, 48, 60])
 numpy.savetxt("mi.csv", a) 

Este código generará un archivo CSV en la ubicación donde se almacena nuestro archivo de código Python.

Puedes eliminar el relleno de ceros adicional de esta manera:

numpy.savetxt("miArray.csv", a,fmt='%.2f')

sort()

 Podemos  ordenar el arreglo NumPy usando el método sort (), que toma como eje  por defecto(-1), que indicará la forma en que queremos ordenar el arreglo, siendo  -1 el ultimo eje.

 import numpy
 x = numpy.array([56, 45, 17, 89, 3, 12, 5])
 print("array ordenado = ", numpy.sort(x)) 

el resultado:

>> array ordenado =  [ 3  5 12 17 45 56 89]

Normalizar un arreglo

Normalizar un arreglo, consiste en colocar los valores de un arreglo dentro de un  rango definido, siguiendo la sintaxís:

x = (x – xmin) / (xmax – xmin)

Con  los métodos max () y min () podemos organizar el array colocando los valores limites que esperamos:

 import numpy
 x= numpy.array([5000, 4800, 160, 80, 1200, 3000, 500])
 xmax = x.max()
 xmin = x.min()
 x = (x - xmin)/(xmax - xmin)
 print("array nomalizado x = \n", x)
 print(xmax )
 print(xmin ) 

 asi obtendremos:

 array nomalizado x =
 [1.  0.95934959 0.01626016 0.  0.22764228 0.59349593  0.08536585]
 5000
 80 

Indexar un arreglo

 import numpy
 x = numpy.array([40, 73, 77, 89])
 print("elemento en el indice 3 = ", x[3]) 

el resultado es:

>>elemento en el indice 3 =  89

Otro ejemplo, de su uso en un array multidimensional

 import numpy
 b = numpy.array([[10, 45, 36], [78, 9, 18]])
 print("elemento en el indice b[0][1] = ", b[0][1]) 

La salida será:

>>elemento en el indice
b[0][1] =  45

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.