Tutorial Numpy: Operaciones matemáticas con arrays de Numpy

Operaciones aritméticas y matemáticas básicas

Numpy proporciona una amplia gama de funciones para realizar operaciones aritméticas y matemáticas básicas sobre arrays. A continuación, se presentan las operaciones aritméticas más comunes:

Suma

Se puede realizar la suma elemento a elemento en dos arrays con el operador + o usando la función numpy.add.

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

c = a + b  # [5, 7, 9]
d = np.add(a, b)  # [5, 7, 9]

Resta

La resta se puede realizar con el operador - o utilizando la función numpy.subtract.

import numpy as np

a = np.array([5, 6, 7])
b = np.array([1, 2, 3])

c = a - b  # [4, 4, 4]
d = np.subtract(a, b)  # [4, 4, 4]

Multiplicación

La multiplicación elemento a elemento se realiza con el operador * o la función numpy.multiply.

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

c = a * b  # [4, 10, 18]
d = np.multiply(a, b)  # [4, 10, 18]

División

Para la división, se puede emplear el operador / o la función numpy.divide.

import numpy as np

a = np.array([10, 20, 30])
b = np.array([2, 4, 5])

c = a / b  # [5.0, 5.0, 6.0]
d = np.divide(a, b)  # [5.0, 5.0, 6.0]

Exponenciación

Numpy permite la exponenciación elemento a elemento utilizando el operador ** o la función numpy.power.

import numpy as np

a = np.array([2, 3, 4])
b = np.array([1, 2, 3])

c = a ** b  # [2, 9, 64]
d = np.power(a, b)  # [2, 9, 64]

Raíz cuadrada

Se puede calcular la raíz cuadrada de cada elemento del array usando numpy.sqrt.

import numpy as np

a = np.array([1, 4, 9, 16])

b = np.sqrt(a)  # [1.0, 2.0, 3.0, 4.0]

Logaritmo

Numpy incluye funciones para calcular logaritmos en diferentes bases. Por ejemplo, numpy.log calcula el logaritmo natural (base e), mientras que numpy.log10 y numpy.log2 calculan los logaritmos en base 10 y 2 respectivamente.

import numpy as np

a = np.array([1, np.e, 10])

natural_log = np.log(a)  # [0.0, 1.0, 2.30258509]
log_base_10 = np.log10(a)  # [0.0, 0.43429448, 1.0]
log_base_2 = np.log2(a)  # [0.0, 1.44269504, 3.32192809]

Trigonometría

Numpy también proporciona funciones para operaciones trigonométricas básicas como numpy.sin, numpy.cos, y numpy.tan, que calculan el seno, coseno, y tangente respectivamente.

import numpy as np

angles = np.array([0, np.pi / 2, np.pi])

sinus = np.sin(angles)  # [0.0000000e+00 1.0000000e+00 1.2246468e-16]
cosine = np.cos(angles)  # [ 1.000000e+00  6.123234e-17 -1.000000e+00]
tangent = np.tan(angles)  # [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]

Suma acumulada

Para calcular la suma acumulada de los elementos de un array se utiliza numpy.cumsum.

import numpy as np

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

cumsum = np.cumsum(a)  # [1, 3, 6, 10]

Estas son algunas de las operaciones aritméticas y matemáticas básicas que se pueden realizar con Numpy. Estas funciones permiten manipular y procesar datos de manera eficiente y son fundamentales para tareas de análisis y procesamiento de datos.

Operaciones de redondeo y ajuste de decimales

Numpy facilita diversas funciones que permiten redondear y ajustar decimales en arrays de forma precisa y controlada. Estas funciones son esenciales cuando se trabaja con valores numéricos que requieren un tratamiento específico de decimales. 

A continuación, se detallan algunas de las más importantes.

Numpy proporciona la función numpy.round para redondear elementos a un número especificado de decimales:

import numpy as np

a = np.array([1.345, 2.678, 3.123])

b = np.round(a, 2)  # [1.34, 2.68, 3.12]

Ajuste de decimales con numpy.fix

La función numpy.fix redondea los valores hacia cero, lo que equivale al truncamiento del número.

import numpy as np

a = np.array([-2.5, 2.3, 1.5, -1.4])

b = np.fix(a)  # [-2., 2., 1., -1.]

Redondeo hacia cero con numpy.trunc

La función numpy.trunc también realiza un truncamiento similar a numpy.fix, eliminando los decimales y manteniendo la parte entera.

import numpy as np

a = np.array([-3.8, 3.5])

b = np.trunc(a)  # [-3., 3.]

Redondeo hacia el infinito más lejano con numpy.floor y numpy.ceil

Para obtener el entero más cercano menor o igual al valor, se utiliza numpy.floor:

import numpy as np

a = np.array([-2.5, 2.3, 3.7])

b = np.floor(a)  # [-3., 2., 3.]

Por otro lado, numpy.ceil permite redondear hacia el entero más cercano mayor o igual al valor:

import numpy as np

a = np.array([-2.5, 2.3, 3.7])

b = np.ceil(a)  # [-2., 3., 4.]

Redondeo al entero más cercano con numpy.rint

La función numpy.rint redondea al entero más cercano, teniendo en cuenta las reglas de redondeo estándar (redondea hacia el número par más cercano si el valor es equidistante entre dos enteros).

import numpy as np

a = np.array([-2.5, 2.3, 3.7])

b = np.rint(a)  # [-2., 2., 4.]

Ajuste de decimales con numpy.around

La función numpy.around permite redondear los valores de un array a un número específico de decimales, similar a numpy.round.

import numpy as np

a = np.array([1.345, 2.678, 3.123])

b = np.around(a, 1)  # [1.3, 2.7, 3.1]

Selección de cifras significativas

Para ajustarse a un número de cifras significativas, se puede usar numpy.around con un segundo parámetro negativo, que representa el número de posiciones después del decimal a considerar.

import numpy as np

a = np.array([1234.5678, 5678.1234])

b = np.around(a, -1)  # [1230.0, 5680.0]

Estas funciones de redondeo y ajuste de decimales proporcionan una gran flexibilidad y precisión en el manejo de valores numéricos en Numpy, permitiendo a los ingenieros de software adaptar los resultados a las necesidades específicas de sus cálculos y aplicaciones.

Ordenación de arrays

Numpy proporciona varias funciones para ordenar arrays, lo que es útil para organizar y analizar datos. A continuación se presentan las principales funciones de ordenación disponibles en Numpy:

Ordenación simple

La función np.sort devuelve una copia del array ordenada a lo largo del eje especificado.

import numpy as np

# Crear un array desordenado
array = np.array([3, 1, 2, 5, 4])

# Ordenar el array
sorted_array = np.sort(array)
print(sorted_array)  # [1, 2, 3, 4, 5]

Para ordenar un array 2D a lo largo de un eje específico:

import numpy as np

# Crear un array 2D desordenado
array_2d = np.array([[3, 1, 2], [5, 4, 6]])

# Ordenar el array a lo largo del eje-0 (filas)
sorted_array_0 = np.sort(array_2d, axis=0)
print(sorted_array_0)
# [[3, 1, 2],
#  [5, 4, 6]]

# Ordenar el array a lo largo del eje-1 (columnas)
sorted_array_1 = np.sort(array_2d, axis=1)
print(sorted_array_1)
# [[1, 2, 3],
#  [4, 5, 6]]

Índices de ordenación

La función np.argsort devuelve los índices que ordenarían un array. Es útil para obtener el orden de los elementos sin modificar el array original.

import numpy as np

# Crear un array desordenado
array = np.array([3, 1, 2, 5, 4])

# Obtener los índices de ordenación
sorted_indices = np.argsort(array)
print(sorted_indices)  # [1, 2, 0, 4, 3]

# Usar los índices para ordenar el array
sorted_array = array[sorted_indices]
print(sorted_array)  # [1, 2, 3, 4, 5]

Ordenación lexicográfica

La función np.lexsort realiza una ordenación lexicográfica utilizando múltiples claves. Las claves se pasan como una tupla.

import numpy as np

# Crear arrays de claves
keys1 = np.array([1, 0, 3, 2])
keys2 = np.array([4, 1, 3, 2])

# Ordenar lexicográficamente usando las dos claves
sorted_indices = np.lexsort((keys2, keys1))
print(sorted_indices)  # [1, 0, 3, 2]

Ordenación parcial

La función np.partition permite reordenar los elementos de un array de manera que todos los elementos menores que un valor de pivote aparezcan antes de dicho valor, y todos los elementos mayores aparezcan después. Es útil para operaciones de selección y ordenación parcial.

import numpy as np

# Crear un array desordenado
array = np.array([7, 2, 3, 1, 6, 5, 4])

# Particionar el array alrededor del 3er elemento
partitioned_array = np.partition(array, 3)
print(partitioned_array)  # Los elementos antes del índice 3 son menores o iguales, y después son mayores

Operaciones lógicas y comparaciones

NumPy proporciona una serie de funciones lógicas y de comparación que facilitan la realización de operaciones condicionales y análisis booleanos sobre arrays. Estas funciones son esenciales para el filtrado de datos y la aplicación de condiciones específicas en la manipulación y análisis de arrays.

Comparaciones elementales

NumPy permite realizar comparaciones elementales entre arrays o entre un array y un escalar. Las principales comparaciones son:

• Igualdad (==): Comprueba si los elementos son iguales.
• Desigualdad (!=): Comprueba si los elementos son diferentes.
• Mayor que (>): Comprueba si los elementos son mayores.
• Menor que (<): Comprueba si los elementos son menores.
• Mayor o igual que (>=): Comprueba si los elementos son mayores o iguales.
• Menor o igual que (<=): Comprueba si los elementos son menores o iguales.

import numpy as np

a = np.array([1, 2, 3])
b = np.array([3, 2, 1])

equal = a == b  # [False, True, False]
not_equal = a != b  # [True, False, True]
greater = a > b  # [False, False, True]
less = a < b  # [True, False, False]
greater_equal = a >= b  # [False, True, True]
less_equal = a <= b  # [True, True, False]

Funciones lógicas elementales

NumPy también proporciona funciones lógicas tales como numpy.logical_and, numpy.logical_or, y numpy.logical_not que permiten realizar operaciones booleanas entre arrays.

import numpy as np

a = np.array([True, False, True])
b = np.array([False, False, True])

logical_and = np.logical_and(a, b)  # [False, False, True]
logical_or = np.logical_or(a, b)  # [True, False, True]
logical_not = np.logical_not(a)  # [False, True, False]

Operaciones de comparación combinadas

Se pueden combinar operaciones lógicas y de comparación para generar condiciones complejas:

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([4, 3, 2, 1])

# Elementos de a que son mayores que 2 y menos de 4
condition = np.logical_and(a > 2, a < 4)  # [False, False, True, False]

# Elementos de a que son mayores que 2 o menores que 2
condition = np.logical_or(a > 2, a < 2)  # [True, False, True, True]

Aplicación de condiciones a arrays

La función numpy.where permite aplicar condiciones de manera eficiente, retornando elementos de uno de dos arrays dependiendo de una condición:

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([4, 3, 2, 1])

# Si el elemento en a es mayor que 2, selecciona el elemento en a; de lo contrario, selecciona el elemento en b
result = np.where(a > 2, a, b)  # [4, 3, 3, 4]

Evaluación lógica de arrays

NumPy permite la evaluación lógica de arrays completos utilizando funciones como numpy.all y numpy.any:

import numpy as np

a = np.array([True, True, False])

all_true = np.all(a)  # False, porque no todos los elementos son True
any_true = np.any(a)  # True, porque al menos un elemento es True

Comparación de arrays completos

Para comparar dos arrays completos y verificar si son iguales, se puede utilizar numpy.array_equal:

import numpy as np

a = np.array([1, 2, 3])
b = np.array([1, 2, 3])
c = np.array([3, 2, 1])

array_equal = np.array_equal(a, b)  # True, porque a y b son iguales
array_not_equal = np.array_equal(a, c)  # False, porque a y c no son iguales

Estas operaciones lógicas y de comparación son herramientas poderosas en NumPy que facilitan la manipulación y análisis de datos de manera eficiente y efectiva, permitiendo a los ingenieros de software implementar lógicas complejas de una forma simple y directa.

Selección y filtrado

El proceso de selección y filtrado en NumPy es fundamental para manipular y analizar datos de manera eficiente. NumPy proporciona varias formas de seleccionar elementos específicos de un array y aplicar filtros basados en condiciones específicas.

Selección de elementos por índices: utilizando índices, puede seleccionar elementos específicos o rangos de elementos en un array. NumPy soporta indexación de arrays de una o múltiples dimensiones.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

element = a[2]  # 3
subset = a[1:4]  # [2, 3, 4]

Selección avanzada: se puede utilizar una lista de índices para seleccionar múltiples elementos.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

selection = a[[0, 2, 4]]  # [1, 3, 5]

Selección con condiciones: utilizando operaciones de comparación y funciones lógicas. Se puede generar un array booleano que indica cuáles elementos cumplen con una condición y usarlo para filtrar el array original.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

greater_than_2 = a[a > 2]  # [3, 4, 5]

Combinación de condiciones: utilizando operadores lógicos (& para AND, | para OR), puede combinar múltiples condiciones.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

between_2_and_4 = a[(a > 2) & (a < 5)]  # [3, 4]

Selección condicional con np.where: numpy.where es útil para reemplazar elementos basados en una condición. Retorna elementos de uno de dos arrays dependiendo de una condición.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

# Si el elemento es mayor que 3, selecciona el -1; si no, el elemento original
condition = np.where(a > 3, -1, a)  # [1, 2, 3, -1, -1]

Aplicar condiciones booleanas: np.any y np.all permiten evaluar condicionalmente arrays en su totalidad o a lo largo de un eje especificado.

import numpy as np

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

any_element_greater_than_4 = np.any(a > 4)  # True
all_elements_greater_than_0 = np.all(a > 0)  # True

Selección en arrays multidimensionales: se pueden seleccionar elementos específicos o sub-arrays utilizando tuplas de índices o slices.

import numpy as np

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

element = a[1, 2]  # 6
subarray = a[:, 1]  # [2, 5]

Indexación booleana: para seleccionar elementos que cumplan con ciertas condiciones en arrays multidimensionales.

import numpy as np

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

condition = a > 3
filtered_elements = a[condition]  # [4, 5, 6]

Selección con np.take: numpy.take permite una selección rápida y directa a lo largo de un eje específico.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

indices = [0, 2, 4]
selected_elements = np.take(a, indices)  # [1, 3, 5]

Estas herramientas de selección y filtrado permiten trabajar con datos de manera precisa y eficiente, facilitando tareas como la limpieza, transformación y análisis de grandes conjuntos de datos.