# Método np.where de Python

La función `np.where()` permite trabajar específicamente con arrays NumPy en Python. Sus operaciones vectorizadas 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 condicional de elementos de un array. Se ocupa de identificar y extraer los elementos que **cumplen una determinada condición**, devolviendo los índices o valores correspondientes.

La función `np.where()` se utiliza en diversos campos, como el procesamiento de datos, la informática científica, el aprendizaje automático y el análisis de datos. En la manipulación de datos, `np.where()` permite **filtrar datos** basándose en ciertos criterios y reemplazar 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:

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

- `condition`: es la condición que se aplica al array para determinar qué elementos deben seleccionarse.
- `x` e `y` (opcional): si solo se especifica `condition`, `np.where()` devuelve los índices de los elementos que cumplen la condición. Si se especifican `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 seleccionando los elementos del array original basándose en una condición. Cada valor `true` o `false` en este array de condiciones corresponde a la selección o filtrado del elemento correspondiente en el array original.

## Ejemplos de uso de `np.where()`

El método `np.where()` es una herramienta muy versátil debido a su capacidad para realizar **operaciones condicionales** sobre arrays y es muy adecuado para manipular datos.

### Reemplazar elementos de un array NumPy

La función `np.where()` de NumPy permite reemplazar elementos de un array basándose en una condición. Puedes convertir [listas Python](https://www.ionos.com/digitalguide/websites/web-development/python-list/) en un array con `np.array()`:

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

Ahora queremos definir una condición para identificar 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:

```python
condition = arr > 3
```

A continuación, utilizamos `np.where()` y especificamos esta condición. Los valores que coinciden con la condición se sustituyen por -1, mientras que todos los demás valores se sustituyen por 0:

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

El resultado, `new_arr`, contiene el array modificado después de reemplazarlo según la condición. La salida mostrará que los valores mayores de 3 han sido reemplazados por -1, mientras que los otros valores han sido reemplazados por 0:

```python
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 especificar valores de sustitución, devuelve una **tupla de índices** donde la condición es `true`.

```python
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 identifica los elementos de `arr` que son mayores de 2. Se llama `np.where(condition)` sin especificar valores de sustitució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.

### Broadcasting con `np.where()`

La transmisión en NumPy permite realizar operaciones entre arrays con formas diferentes siempre que se cumplan ciertas reglas. Si los arrays tienen formas diferentes, NumPy intenta ampliarlas para que sean compatibles.

Supongamos que tenemos un array NumPy `arr` con la forma (3, 3):

```python
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,):

```python
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 exactamente, la transmisió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 transmisión:

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

La `row` unidimensional se amplió a una matriz (3, 3) para que coincidiera con la forma de `arr`, repitiéndola en las filas. A continuación, los elementos de `arr` y `row` se suman elemento a elemento.


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/metodo-npwhere-de-python/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/metodo-npwhere-de-python/) for AI/LLM consumption.