Mis on np.where Pythonis?

Pythonis NumPy mas­sii­vi­dega töö­ta­miseks võite kasutada funkt­siooni np.where(). Selle vek­to­ri­see­ri­tud ope­rat­sioo­nid muudavad selle tõ­hu­samaks kui sil­mus­põ­hi­sed meetodid.

Mida teeb np.where?

Python-funkt­sioon np.where() on NumPy-teegi võimas meetod, mida ka­su­ta­takse massiivi ele­men­tide va­li­miseks. See tuvastab ja eraldab elemendid, mis vastavad teatud tin­gi­mu­sele, ning tagastab seejärel selle tin­gi­mu­sele vastavad indeksid või väärtused.

Seda funkt­siooni ka­su­ta­takse mit­me­su­gus­tes vald­kon­da­des, näiteks and­me­tööt­luses, tea­dus­li­kes ar­vu­tus­tes, ma­si­nõp­pes ja andmete analüüsis. Andmete tööt­le­misel võimaldab np.where() filt­ree­rida andmeid ja asendada väärtusi mas­sii­vi­des.

Mis on np.where süntaks Pythonis?

Funkt­sioon np.where() võtab vastu NumPy-laadse massiivi, mis koosneb näiteks täis­ar­vu­dest või booli väär­tus­test. Selle süntaks on järgmine:

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

• condition: See on tingimus, mida ra­ken­da­takse massiivi suhtes, et määrata, millised elemendid valitakse.
• x ja y (va­li­ku­line): kui mää­ra­takse x ja y, ta­gas­ta­takse tingimuse täitmise korral väärtused x. Muidu ta­gas­ta­takse väärtused y. Kui x ja y ei ole määratud, tagastab np.where() tin­gi­mus­tele vastavad indeksid.

Pärast täitmist tagastab np.where() uue NumPy massiivi. Uus massiiv on tingimuse alusel algse massiivi ele­men­tide filt­ree­ri­mise või valimise tulemus.

Näited np.where ka­su­ta­mise kohta

np.where() on mit­me­külgne vahend tin­gi­muste ra­ken­da­miseks mas­sii­vi­dele ja on väga kasulik andmete tööt­le­misel. Allpool vaatame mõningaid näiteid selle ka­su­ta­mise kohta.

NumPy massiivi ele­men­tide asen­da­mine

NumPy funkt­sioon np.where() võimaldab asendada massiivi elemente tingimuse alusel. Enne alus­ta­mist saate muuta Python loendeid mas­sii­vi­deks, kasutades np.array().

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

Nüüd, kui meil on massiiv olemas, tahame mää­rat­leda tingimuse, mille alusel tuvastada elemendid, mis on suuremad kui 3. Selleks võime kasutada tingimust, mis on True ele­men­tide puhul, mis on suuremad kui 3, ja muul juhul vale:

condition = arr > 3

Järg­misena kasutame np.where() ja sisestame selle tingimuse. Samuti määrame, et tin­gi­mu­sele vastavad väärtused asen­da­takse -1-ga ja kõik muud väärtused asen­da­takse 0-ga.

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

Tu­le­mu­seks on new_arr, mis sisaldab tingimuse alusel muudetud massiivi. Väljundis asen­da­takse väärtused, mis on suuremad kui 3, väär­tu­sega -1. Kõik muud väärtused asen­da­takse väär­tu­sega 0.

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

Kasuta np.where ühe tin­gi­mu­sega

Kui kasutate np.where() ainult ühe tin­gi­mu­sega ja asen­dus­väär­tus­teta, tagastab see indeksite tupli, mille puhul tingimus on tõene.

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

Selles näites on arr NumPy massiiv, mis sisaldab väärtusi 1 kuni 5. condition = arr > 2 loob Boole’i maski, mis tuvastab elemendid arr, mis on suuremad kui 2. np.where(condition) täi­de­takse asen­dus­väär­tus­teta ja tu­le­mu­seks on indeksite tupl, mis vastab tin­gi­mu­sele arr > 2. Väl­jun­diks on indeksite massiiv, mille elemendid on suuremad kui 2.

Saade np.where abil

NumPy-s võimaldab ring­hää­ling teha ope­rat­sioone erineva kujuga mas­sii­vi­dega, kui on täidetud teatud tin­gi­mu­sed. Kui massiivid on erineva kujuga, püüab NumPy neid suu­ren­dada, et need oleksid ühilduvad.

Oletame, et meil on NumPy massiiv arr kujul (3, 3):

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

Ja meil on veel üks NumPy massiiv row kujul (3,):

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

Kahe massiivi vormid ei ole päris ühe­su­gu­sed, kuid nende vaheliste ope­rat­sioo­nide või­mal­da­miseks saab kasutada le­vi­ta­mist. Kui me näiteks tahaksime liita iga rea arr väärtused row väär­tus­tega, või­mal­daks le­vi­ta­mine seda teha.

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

Eespool toodud näites suu­ren­dati ühe­mõõt­me­line massiiv row (3, 3) maat­rik­siks, et see vastaks kujule arr. Seejärel liideti elemendid arr ja row ele­men­tide kaupa kokku.