Método np.where de Python

La función np.where() permite trabajar es­pe­cí­fi­ca­me­n­te con arrays NumPy en Python. Sus ope­ra­cio­nes ve­c­to­ri­za­das la hacen más eficiente que los métodos basados en bucles.

¿Para qué sirve np.where de Python?

La función np.where() en Python es un potente método de la librería NumPy adecuado para la selección co­n­di­cio­nal de elementos de un array. Se ocupa de ide­n­ti­fi­car y extraer los elementos que cumplen una de­te­r­mi­na­da condición, de­vo­l­vie­n­do los índices o valores co­rre­s­po­n­die­n­tes.

La función np.where() se utiliza en diversos campos, como el pro­ce­sa­mie­n­to de datos, la in­fo­r­má­ti­ca cie­n­tí­fi­ca, el apre­n­di­za­je au­to­má­ti­co y el análisis de datos. En la ma­ni­pu­la­ción de datos, np.where() permite filtrar datos basándose en ciertos criterios y re­em­pla­zar valores en arrays.

La sintaxis de np.where() de Python

La función np.where() acepta un array de tipo NumPy formado por enteros o valores booleanos, por ejemplo. La sintaxis de la función np.where() en Python es la siguiente:

import numpy as np 
 
np.where(condition[, x, y])

• condition: es la condición que se aplica al array para de­te­r­mi­nar qué elementos deben se­le­c­cio­nar­se.
• x e y (opcional): si solo se es­pe­ci­fi­ca condition, np.where() devuelve los índices de los elementos que cumplen la condición. Si se es­pe­ci­fi­can x e y, se devuelven los valores de x cuando se cumple la condición, y los valores de y en caso contrario.

Después de llamar a la función np.where(), ésta devuelve como resultado un nuevo array NumPy. Este nuevo array se crea filtrando o se­le­c­cio­na­n­do los elementos del array original basándose en una condición. Cada valor true o false en este array de co­n­di­cio­nes co­rre­s­po­n­de a la selección o filtrado del elemento co­rre­s­po­n­die­n­te en el array original.

Ejemplos de uso de np.where()

El método np.where() es una he­rra­mie­n­ta muy versátil debido a su capacidad para realizar ope­ra­cio­nes co­n­di­cio­na­les sobre arrays y es muy adecuado para manipular datos.

Re­em­pla­zar elementos de un array NumPy

La función np.where() de NumPy permite re­em­pla­zar elementos de un array basándose en una condición. Puedes convertir listas Python en un array con np.array():

import numpy as np 
 
arr = np.array([1, 2, 3, 4, 5])

Ahora queremos definir una condición para ide­n­ti­fi­car los elementos que son mayores de 3. Esto se hace mediante la creación de una máscara de condición que sea true para los elementos mayores de 3 y false en caso contrario:

condition = arr > 3

A co­n­ti­nua­ción, uti­li­za­mos np.where() y es­pe­ci­fi­ca­mos esta condición. Los valores que coinciden con la condición se su­s­ti­tu­yen por -1, mientras que todos los demás valores se su­s­ti­tu­yen por 0:

new_arr = np.where(condition, -1, 0)

El resultado, new_arr, contiene el array mo­di­fi­ca­do después de re­em­pla­zar­lo según la condición. La salida mostrará que los valores mayores de 3 han sido re­em­pla­za­dos por -1, mientras que los otros valores han sido re­em­pla­za­dos por 0:

print(new_arr) 
# Output: [0 0 0 -1 -1]

Utilizar np.where() con una sola condición

Si numpy.where() solo se utiliza con una condición y sin es­pe­ci­fi­car valores de su­s­ti­tu­ción, devuelve una tupla de índices donde la condición es true.

import numpy as np 
arr = np.array([1, 2, 3, 4, 5]) 
condition = arr > 2 
result = np.where(condition) 
print(result) 
# Output: (array([2, 3, 4]))

En este ejemplo, arr es un array NumPy que contiene valores de 1 a 5. Con condition = arr > 2 se crea una máscara booleana que ide­n­ti­fi­ca los elementos de arr que son mayores de 2. Se llama np.where(condition) sin es­pe­ci­fi­car valores de su­s­ti­tu­ción. Esto devolverá una tupla de índices donde la condición arr > 2 es verdadera. La salida será un array de índices donde los elementos de arr son mayores de 2.

Broa­d­ca­s­ti­ng con np.where()

La tra­n­s­mi­sión en NumPy permite realizar ope­ra­cio­nes entre arrays con formas di­fe­re­n­tes siempre que se cumplan ciertas reglas. Si los arrays tienen formas di­fe­re­n­tes, NumPy intenta am­pliar­las para que sean co­m­pa­ti­bles.

Su­po­n­ga­mos que tenemos un array NumPy arr con la forma (3, 3):

import numpy as np 
arr = np.array([[1, 2, 3], 
    [4, 5, 6], 
    [7, 8, 9]])

Y tenemos otro array NumPy row con la forma (3,):

row = np.array([10, 11, 12])

Aquí se muestra la forma de arr (3, 3) y la forma de row (3,). Aunque las formas no coinciden exac­ta­me­n­te, la tra­n­s­mi­sión se puede utilizar para realizar una operación entre estos arrays.

Ahora queremos añadir los valores de cada fila de arr a los valores de row. Aquí es donde entra en juego la tra­n­s­mi­sión:

result = arr + row 
print(result) 
# Output: [11 13 15] 
    [14 16 18] 
    [17 19 21]

La row uni­di­me­n­sio­nal se amplió a una matriz (3, 3) para que coin­ci­die­ra con la forma de arr, re­pi­tié­n­do­la en las filas. A co­n­ti­nua­ción, los elementos de arr y row se suman elemento a elemento.