# Mis on np.where Pythonis?

Pythonis NumPy massiividega töötamiseks võite kasutada funktsiooni `np.where()`. Selle vektoriseeritud operatsioonid muudavad selle tõhusamaks kui silmuspõhised meetodid.

## Mida teeb np.where?

Python-funktsioon `np.where()` on NumPy-teegi võimas meetod, mida kasutatakse massiivi elementide valimiseks. See tuvastab ja eraldab elemendid, mis **vastavad teatud tingimusele**, ning tagastab seejärel selle tingimusele vastavad indeksid või väärtused.

Seda funktsiooni kasutatakse mitmesugustes valdkondades, näiteks andmetöötluses, teaduslikes arvutustes, masinõppes ja andmete analüüsis. Andmete töötlemisel võimaldab `np.where()` **filtreerida andmeid** ja asendada väärtusi massiivides.

## Mis on np.where süntaks Pythonis?

Funktsioon `np.where()` võtab vastu **NumPy-laadse massiivi**, mis koosneb näiteks täisarvudest või booli väärtustest. Selle süntaks on järgmine:

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

- `condition`: See on tingimus, mida rakendatakse massiivi suhtes, et määrata, millised elemendid valitakse.
- `x` ja `y` (valikuline): kui määratakse `x` ja `y`, tagastatakse tingimuse täitmise korral väärtused `x`. Muidu tagastatakse väärtused `y`. Kui `x` ja `y` ei ole määratud, tagastab `np.where()` tingimustele vastavad indeksid.

Pärast täitmist tagastab `np.where()` **uue NumPy massiivi**. Uus massiiv on tingimuse alusel algse massiivi elementide filtreerimise või valimise tulemus.

## Näited np.where kasutamise kohta

`np.where()` on mitmekülgne vahend tingimuste rakendamiseks massiividele ja on väga kasulik andmete töötlemisel. Allpool vaatame mõningaid näiteid selle kasutamise kohta.

### NumPy massiivi elementide asendamine

NumPy funktsioon `np.where()` võimaldab asendada massiivi elemente tingimuse alusel. Enne alustamist saate muuta Python loendeid massiivideks, kasutades `np.array()`.

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

Nüüd, kui meil on massiiv olemas, tahame määratleda tingimuse, mille alusel tuvastada elemendid, mis on suuremad kui 3. Selleks võime kasutada tingimust, mis on `True` elementide puhul, mis on suuremad kui 3, ja muul juhul vale:

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

Järgmisena kasutame `np.where()` ja sisestame selle tingimuse. Samuti määrame, et tingimusele vastavad väärtused asendatakse -1-ga ja kõik muud väärtused asendatakse 0-ga.

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

Tulemuseks on `new_arr`, mis sisaldab tingimuse alusel muudetud massiivi. Väljundis asendatakse väärtused, mis on suuremad kui 3, väärtusega -1. Kõik muud väärtused asendatakse väärtusega 0.

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

### Kasuta np.where ühe tingimusega

Kui kasutate `np.where()` ainult ühe tingimusega ja asendusväärtusteta, tagastab see **indeksite tupli**, mille puhul tingimus on tõene.

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

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äidetakse asendusväärtusteta ja tulemuseks on indeksite tupl, mis vastab tingimusele `arr > 2`. Väljundiks on indeksite massiiv, mille elemendid on suuremad kui 2.

### Saade np.where abil

NumPy-s võimaldab ringhääling teha operatsioone erineva kujuga massiividega, kui on täidetud teatud tingimused. Kui massiivid on erineva kujuga, püüab NumPy neid suurendada, et need oleksid ühilduvad.

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

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

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

Kahe massiivi vormid ei ole päris ühesugused, kuid nende vaheliste operatsioonide võimaldamiseks saab kasutada levitamist. Kui me näiteks tahaksime liita iga rea `arr` väärtused `row` väärtustega, võimaldaks levitamine seda teha.

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

Eespool toodud näites suurendati ühemõõtmeline massiiv `row` (3, 3) maatriksiks, et see vastaks kujule `arr`. Seejärel liideti elemendid `arr` ja `row` elementide kaupa kokku.


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/python-npwhere-meetod/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/python-npwhere-meetod/) for AI/LLM consumption.