# Método np.where do Python

A função `np.where()` permite trabalhar especificamente com matrizes NumPy em Python. As suas operações vetorizadas tornam-na mais eficiente do que os métodos baseados em loops.

## Para que serve o np.where do Python?

A função `np.where()` em Python é um método poderoso da biblioteca NumPy adequado para a seleção condicional de elementos de uma matriz. Ela identifica e extrai os elementos que **atendem a uma determinada condição**, retornando os índices ou valores correspondentes.

A função `np.where()` é utilizada em vários campos, como processamento de dados, computação científica, aprendizagem automática e análise de dados. Na manipulação de dados, `np.where()` permite **filtrar dados** com base em determinados critérios e substituir valores em matrizes.

## A sintaxe do Python `np.where()`

A função `np.where()` aceita uma matriz do tipo **NumPy** composta por inteiros ou valores booleanos, por exemplo. A sintaxe da função `np.where()` em Python é a seguinte:

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

- `condition`: é a condição aplicada à matriz para determinar quais elementos devem ser selecionados.
- `x` e `y` (opcional): se apenas `condition` for especificado, `np.where()` retorna os índices dos elementos que satisfazem a condição. Se `x` e `y` forem especificados, os valores de `x` são retornados quando a condição é satisfeita e os valores de `y` caso contrário.

Depois de chamar a função `np.where()`, ela retorna como resultado um **novo array NumPy**. Esse novo array é criado filtrando ou selecionando os elementos do array original com base em uma condição. Cada valor `true` ou `false` nesse array de condições corresponde à seleção ou filtragem do elemento correspondente no array original.

## Exemplos de utilização de `np.where()`

O método `np.where()` é uma ferramenta muito versátil devido à sua capacidade de realizar **operações condicionais** em matrizes e é muito adequado para manipular dados.

### Substituir elementos de uma matriz NumPy

A função `np.where()` do NumPy permite substituir elementos de uma matriz com base numa condição. Pode converter listas Python numa matriz com `np.array()`:

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

Agora queremos definir uma condição para identificar os elementos que são maiores que 3. Isso é feito criando uma máscara de condição que seja `true` para os elementos maiores que 3 e `false` caso contrário:

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

Em seguida, utilizamos `np.where()` e especificamos essa condição. Os valores que correspondem à condição são substituídos por -1, enquanto todos os outros valores são substituídos por 0:

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

O resultado, `new_arr`, contém a matriz modificada após a substituição de acordo com a condição. A saída mostrará que os valores maiores que 3 foram substituídos por -1, enquanto os outros valores foram substituídos por 0:

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

### Utilizar `np.where()` com uma única condição

Se `numpy.where()` for utilizado apenas com uma condição e sem especificar valores de substituição, ele retorna uma **tupla de índices** onde a condição é `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]))
```

Neste exemplo, `arr` é uma matriz NumPy que contém valores de 1 a 5. Com `condition = arr > 2`, é criada uma **máscara booleana** que identifica os elementos de `arr` que são maiores que 2. É chamado `np.where(condition)` sem especificar valores de substituição. Isso retornará uma tupla de índices onde a condição `arr > 2` é verdadeira. A saída será uma matriz de índices onde os elementos de `arr` são maiores que 2.

### Transmissão com `np.where()`

A transmissão no NumPy permite realizar operações entre matrizes com formas diferentes, desde que sejam cumpridas determinadas regras. Se as matrizes tiverem formas diferentes, o NumPy tenta ampliá-las para que sejam compatíveis.

Suponhamos que temos uma matriz NumPy `arr` com a forma (3, 3):

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

E temos outro array NumPy `row` com a forma (3,):

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

Aqui é mostrada a forma de `arr` (3, 3) e a forma de `row` (3,). Embora as formas não coincidam exatamente, a transmissão pode ser usada para realizar uma operação entre esses matrizes.

Agora queremos adicionar os valores de cada linha de `arr` aos valores de `row`. É aqui que entra em jogo a transmissão:

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

A `row` unidimensional foi ampliada para uma matriz (3, 3) para coincidir com a forma da `arr`, repetindo-a nas linhas. Em seguida, os elementos da `arr` e `row` são somados elemento a elemento.


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