Wat is np.where in Python?

Je kunt de functie np.where() gebruiken om met NumPy-arrays in Python te werken. Dankzij de ge­vec­to­ri­seer­de be­wer­kin­gen is deze functie ef­fi­ci­ën­ter dan op loops ge­ba­seer­de methoden.

Wat doet np.where?

De Python-functie np.where() is een krachtige methode uit de NumPy-bi­bli­o­theek en wordt gebruikt voor het se­lec­te­ren van elementen uit een array. Het iden­ti­fi­ceert en ex­tra­heert elementen die aan een bepaalde voor­waar­de voldoen en re­tour­neert ver­vol­gens indices of waarden die aan die voor­waar­de voldoen.

De functie wordt gebruikt in ver­schil­len­de domeinen, zoals ge­ge­vens­ver­wer­king, we­ten­schap­pe­lij­ke be­re­ke­nin­gen, machine learning en ge­ge­vens­ana­ly­se. Bij ge­ge­vens­ma­ni­pu­la­tie maakt np.where() het mogelijk om gegevens te filteren en waarden in arrays te vervangen.

Wat is de syntaxis van np.where in Python?

De functie np.where() neemt een NumPy-achtige array die bestaat uit bij­voor­beeld gehele getallen of Boole­aan­se waarden. De syntaxis ziet er als volgt uit:

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

• condition: Dit is de voor­waar­de die op de array wordt toegepast om te bepalen welke elementen worden ge­se­lec­teerd.
• x en y (optioneel): Als u x en y opgeeft, worden de waarden uit x ge­re­tour­neerd wanneer aan de voor­waar­de wordt voldaan. Anders worden de waarden uit y ge­re­tour­neerd. Als u x en y niet opgeeft, re­tour­neert np.where() de indices die aan de voor­waar­de voldoen.

Na uit­voe­ring re­tour­neert np.where() een nieuwe NumPy-array. De nieuwe array is het resultaat van het filteren of se­lec­te­ren van elementen uit de oor­spron­ke­lij­ke array op basis van de voor­waar­de.

Voor­beel­den van het gebruik van np.where

De np.where() is een veel­zij­dig hulp­mid­del voor het toepassen van voor­waar­den op arrays en is erg handig voor het bewerken van gegevens. Hieronder bekijken we enkele voor­beel­den van hoe je deze methode kunt gebruiken.

Elementen in een NumPy-array vervangen

Met de functie np.where() in NumPy kun je elementen in een array vervangen op basis van een voor­waar­de. Voordat je begint, kun je Python-lijsten omzetten in arrays met behulp van np.array().

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

Nu we onze array hebben, willen we een voor­waar­de de­fi­ni­ë­ren om elementen groter dan 3 te iden­ti­fi­ce­ren. We kunnen dit doen met een voor­waar­de die True is voor elementen die groter zijn dan 3 en anders false:

condition = arr > 3

Ver­vol­gens gebruiken we np.where() en voeren we deze voor­waar­de in. We stellen ook vast dat waarden die aan de voor­waar­de voldoen, worden vervangen door -1 en alle andere waarden worden vervangen door 0.

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

Het resultaat, new_arr, bevat de array die op basis van de voor­waar­de is gewijzigd. In de uitvoer worden waarden die groter zijn dan 3 vervangen door -1. Alle andere waarden worden vervangen door 0.

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

Gebruik np.where met één voor­waar­de

Als u np.where() gebruikt met slechts één voor­waar­de en zonder ver­van­gen­de waarden, re­tour­neert het een tuple van indices waarvoor de voor­waar­de waar is.

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

In dit voorbeeld is arr een NumPy-array die waarden van 1 tot 5 bevat. condition = arr > 2 creëert een Booleaans masker dat elementen in arr iden­ti­fi­ceert die groter zijn dan 2. np.where(condition) wordt uit­ge­voerd zonder ver­van­gen­de waarden en re­tour­neert als resultaat een tuple van indices die voldoen aan de voor­waar­de arr > 2. De uitvoer is een array van indices waarin de elementen groter zijn dan 2.

Uit­zen­ding met np.where

In NumPy maakt broad­cas­ting het mogelijk om be­wer­kin­gen uit te voeren met arrays van ver­schil­len­de vormen, mits aan bepaalde voor­waar­den wordt voldaan. Wanneer arrays ver­schil­len­de vormen hebben, zal NumPy proberen ze te vergroten zodat ze com­pa­ti­bel zijn.

Stel dat we een NumPy-array arr hebben met de vorm (3, 3):

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

En we hebben nog een NumPy-array row met de vorm (3,):

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

De vormen van de twee arrays komen niet helemaal overeen, maar met behulp van broad­cas­ting kunnen be­wer­kin­gen tussen beide worden uit­ge­voerd. Als we bij­voor­beeld de waarden van elke rij van arr willen optellen bij de waarden in row, dan is dat mogelijk met broad­cas­ting.

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

In het bo­ven­staan­de voorbeeld werd de een­di­men­si­o­na­le array row vergroot tot een (3, 3) matrix om overeen te komen met de vorm van arr. Ver­vol­gens werden de elementen van arr en row element voor element bij elkaar opgeteld.