Método np.where do Python

A função np.where() permite trabalhar es­pe­ci­fi­ca­mente com matrizes NumPy em Python. As suas operações ve­to­ri­za­das 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 bi­bli­o­teca NumPy adequado para a seleção con­di­ci­o­nal de elementos de uma matriz. Ela iden­ti­fica e extrai os elementos que atendem a uma de­ter­mi­nada condição, re­tor­nando os índices ou valores cor­res­pon­den­tes.

A função np.where() é utilizada em vários campos, como pro­ces­sa­mento de dados, com­pu­ta­ção ci­en­tí­fica, apren­di­za­gem au­to­má­tica e análise de dados. Na ma­ni­pu­la­ção de dados, np.where() permite filtrar dados com base em de­ter­mi­na­dos critérios e subs­ti­tuir 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:

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

• condition: é a condição aplicada à matriz para de­ter­mi­nar quais elementos devem ser se­le­ci­o­na­dos.
• x e y (opcional): se apenas condition for es­pe­ci­fi­cado, np.where() retorna os índices dos elementos que sa­tis­fa­zem a condição. Se x e y forem es­pe­ci­fi­ca­dos, os valores de x são re­tor­na­dos quando a condição é sa­tis­feita 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 se­le­ci­o­nando os elementos do array original com base em uma condição. Cada valor true ou false nesse array de condições cor­res­ponde à seleção ou filtragem do elemento cor­res­pon­dente no array original.

Exemplos de uti­li­za­ção de np.where()

O método np.where() é uma fer­ra­menta muito versátil devido à sua ca­pa­ci­dade de realizar operações con­di­ci­o­nais em matrizes e é muito adequado para manipular dados.

Subs­ti­tuir elementos de uma matriz NumPy

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

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

Agora queremos definir uma condição para iden­ti­fi­car 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:

condition = arr > 3

Em seguida, uti­li­za­mos np.where() e es­pe­ci­fi­ca­mos essa condição. Os valores que cor­res­pon­dem à condição são subs­ti­tuí­dos por -1, enquanto todos os outros valores são subs­ti­tuí­dos por 0:

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

O resultado, new_arr, contém a matriz mo­di­fi­cada após a subs­ti­tui­ção de acordo com a condição. A saída mostrará que os valores maiores que 3 foram subs­ti­tuí­dos por -1, enquanto os outros valores foram subs­ti­tuí­dos por 0:

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 es­pe­ci­fi­car valores de subs­ti­tui­ção, ele retorna uma tupla de índices onde a condição é 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]))

Neste exemplo, arr é uma matriz NumPy que contém valores de 1 a 5. Com condition = arr > 2, é criada uma máscara booleana que iden­ti­fica os elementos de arr que são maiores que 2. É chamado np.where(condition) sem es­pe­ci­fi­car valores de subs­ti­tui­ção. Isso retornará uma tupla de índices onde a condição arr > 2 é ver­da­deira. A saída será uma matriz de índices onde os elementos de arr são maiores que 2.

Trans­mis­são com np.where()

A trans­mis­são no NumPy permite realizar operações entre matrizes com formas di­fe­ren­tes, desde que sejam cumpridas de­ter­mi­na­das regras. Se as matrizes tiverem formas di­fe­ren­tes, o NumPy tenta ampliá-las para que sejam com­pa­tí­veis.

Su­po­nha­mos que temos uma matriz NumPy arr com a forma (3, 3):

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

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 exa­ta­mente, a trans­mis­sã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 trans­mis­são:

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

A row uni­di­men­si­o­nal 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.