En este post, continuo con las notas de la libreria Numpy. Me centraré en las explicaciones de las operaciones con los arrays de Numpy. Si es tu primer contacto con Numpy, probablemente sea mejor que eches un vistazo al primer post de Numpy.
Modificación de un array
Empezamos creando un Array unidimensional inicializado con los valores 0-14
array = np.arange(15)
print(f"Dimensiones: {array.shape}")
print(f"Array: \n {array}")
El resultado del script anterior sería:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
Empleamos el método shape para definir las dimensiones de un Array y sus longitudes
array.shape = (3, 5)
print(f"Dimensiones: {array.shape}")
print(f"Array:\n {array}")
El resultado de ejecutar el código anterior es:
Dimensiones: (3, 5)
Array:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
Podemos usar el método reshape para modificar las dimensiones de un array. Este método nos devuelve un nuevo Array que apunta a los mismos datos. Cualquier modificación en un array modificará también el otro.
Modificando un array con reshape:
array_1 = np.arange(12)
print(f"array_1: \n {array_1}")
array_2 = array_1.reshape(3, 4)
print(f"array_2: \n {array_2}")
El resultado sería:
array_1:
[ 0 1 2 3 4 5 6 7 8 9 10 11]
array_2:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
Modificación del nuevo array:
array_2[1, 1] = 255
print(f"array_2: \n {array_2}")
print(f"array_1: \n {array_1}")
Que nos da el resultado:
array_2:
[[ 0 1 2 3]
[ 4 255 6 7]
[ 8 9 10 11]]
array_1:
[ 0 1 2 3 4 255 6 7 8 9 10 11]
Donde se puede observar que se han modificado ambos arrays, ya que el nuevo array apuntaba a los mismos datos que el array inicial
Añadir elementos a un array
Podemos añadir elementos al final del array con la función append. Entrega el resultado en un vector lineal.
numeros=[2,3,4]
numeros.append(34)
print(números)
array_1 = np.arange(7)
elemento_añadir=9
array_2 = np.append(array_1,elemento_añadir)
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
El resultado es:
array_1:
[0 1 2 3 4 5 6]
array_2:
[0 1 2 3 4 5 6 9]
Los argumentos de la función append son el array de partida y el elemento que queramos añadir a dicho array.
O podemos añadir un valor en la posición que le indiquemos con el índice.
array_1 = np.arange(7)
posicion =2
elemento_añadir=9
array_2 = np.insert (array_1,posicion,elemento_añadir)
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[0 1 2 3 4 5 6]
array_2:
[0 1 9 2 3 4 5 6]
El método insert requiere tres parámetros: el array de partida, la posición en la que queremos insertar el elemento y el valor que queremos insertar.
Eliminar elementos de un array
Podemos eliminar elementos por su posición en el array, para lo que usaremos el índice.
Usando la técnica de slicing, indicando los índices que queramos eliminar.
array_1=np.arange(1,7)
indice_eliminar=1
array_2=np.delete(array_1,indice_eliminar)
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[1 2 3 4 5 6]
array_2:
[1 3 4 5 6]
O también podemos pasar una lista de los índices a eliminar
array_1=np.arange(1,7)
indices_eliminar=[1,3,5]
array_2=np.delete(array_1,indices_eliminar)
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[1 2 3 4 5 6]
array_2:
[1 3 5]
También podemos eliminar elementos por su valor, para lo que usaremos o bien una máscara booleana o el método where.
Utilizando una máscara booleana
array_1=np.arange(1,7)
mascara= array_1>=4
array_2= array_1 [mascara]
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[1 2 3 4 5 6]
array_2:
[4 5 6]
Utilizando el método where
array_1=np.arange(1,7)
condicion= array_1>4
array_2=np.delete(array_1, np.where(condicion))
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[1 2 3 4 5 6]
array_2:
[1 2 3 4]
Modificando valores a partir de una condición
Empleando el método where, podemos establecer condiciones para cambiar los valores de un array.
array_1=np.arange(1,11)
condicion= array_1>9
array_2=np.where(condicion,"Si","No")
print(f"array_1: \n {array_1}")
print(f"array_2: \n {array_2}")
Resultado:
array_1:
[ 1 2 3 4 5 6 7 8 9 10]
array_2:
['No' 'No' 'No' 'No' 'No' 'No' 'No' 'No' 'No' 'Si']
El método devuelve un array sustituyendo los términos en los que se cumple la condición por el segundo parámetro y los que no cumplen la condición por el tercer parámetro. Tiene un funcionamiento similar a la función IF de Excel.
Operaciones aritméticas con arrays
Creación de dos Arrays unidimensionales
array_1 = np.arange(1, 14, 2)
array_2 = np.arange(1,8)
print(f"Array 1: {array_1}")
print(f"Array 2: {array_2}")
Resultado:
Array 1: [ 1 3 5 7 9 11 13]
Array 2: [1 2 3 4 5 6 7]
Suma de arrays
print(f"Array 1: {array_1}")
print(f"Array 2: {array_2}")
array_suma=array_1 + array_2
print(f"Suma: {array_suma}")
Resultado
Array 1: [ 1 3 5 7 9 11 13]
Array 2: [1 2 3 4 5 6 7]
Suma: [ 2 5 8 11 14 17 20]
Resta de arrays
print(f"Array 1: {array_1}")
print(f"Array 2: {array_2}")
array_resta=array_1 - array_2
print(f"Resta: {array_resta}")
Resultado:
Array 1: [ 1 3 5 7 9 11 13]
Array 2: [1 2 3 4 5 6 7]
Resta: [0 1 2 3 4 5 6]
Multiplicación. Importante: No es una multiplicación de matrices
print(f"Array 1: {array_1}")
print(f"Array 2: {array_2}")
array_multiplicacion=array_1 * array_2
print(f"Multiplicación: {array_multiplicacion}")
Resultado:
Array 1: [ 1 3 5 7 9 11 13]
Array 2: [1 2 3 4 5 6 7]
Multiplicación: [ 1 6 15 28 45 66 91]
División. Importante: Obtendremos un error si hay alguna división por cero
print(f"Array 1: {array_1}")
print(f"Array 2: {array_2}")
array_division=array_1 / array_2
print(f"División: {array_division}")
Resultado:
Array 1: [ 1 3 5 7 9 11 13]
Array 2: [1 2 3 4 5 6 7]
División: [1. 1.5 1.66666667 1.75 1.8 1.83333333
1.85714286]
Cálculos estadísticos
Numpy proporciona varios métodos para realizar cálculos estadísticos.
En el siguiente programa puede verse varios de estos métodos:
array = np.arange(1,21)
maximo=array.max() #Devuelve el valor máximo del array
minimo=array.min() #Devuelve el valor mínimo del array
media=array.mean() #Media de los elementos del array
suma=array.sum() #Suma de los elementos del array
desviacion_std=array.std() #Desviación estándar de los elementos del array
# Funciones universales eficientes proporcionadas por numpy: ufunc
cuadrado=np.square(array) #Cuadrado de los elementos del array
raiz=np.sqrt(array) #Raiz cuadrada de los elementos del array
exponencial=np.exp(array) #Exponencial de los elementos del array
logaritmo=np.log(array) #Logaritmos de los elementos del array
print(f"Array: \n {array}")
print(f"el elemento mayor del array es: {maximo}")
print(f"el elemento menor del array es: {minimo}")
print(f"la suma de los elementos del array es: {suma}")
print(f"la media de los elementos del array es: {media}")
print(f"la desviación estandard de los elementos del array es: {desviacion_std}")
print("ARRAYS")
print(f"El array con los elementos al cuadrado es: \n {cuadrado}")
print(f"El array con las raices cuadradas de los elementos es: \n {raiz}")
print(f"El array con el exponencial de los elementos es: \n {exponencial}")
print(f"El array con el logaritmo de los elementos es: \n {logaritmo}")
Resultado:
Array:
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]
el elemento mayor del array es: 20
el elemento menor del array es: 1
la suma de los elementos del array es: 210
la media de los elementos del array es: 10.5
la desviación estandard de los elementos del array es: 5.766281297335398
ARRAYS
El array con los elementos al cuadrado es:
[ 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324
361 400]
El array con las raices cuadradas de los elementos es:
[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 4. 4.12310563 4.24264069
4.35889894 4.47213595]
El array con el exponencial de los elementos es:
[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 8.88611052e+06
2.41549528e+07 6.56599691e+07 1.78482301e+08 4.85165195e+08]
El array con el logaritmo de los elementos es:
[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 2.77258872 2.83321334 2.89037176
2.94443898 2.99573227]
NOTA:
Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.