# Hva er np.where i Python?

Du kan bruke funksjonen `np.where()` til å arbeide med NumPy-matriser i Python. Dens vektoriserte operasjoner gjør den mer effektiv enn sløyfebaserte metoder.

## Hva gjør np.where?

Python-funksjonen `np.where()` er en kraftig metode fra NumPy-biblioteket og brukes til å velge elementer fra en matrise. Den identifiserer og trekker ut elementer som **oppfyller en bestemt betingelse**, og returnerer deretter indekser eller verdier som tilsvarer denne betingelsen.

Funksjonen brukes innenfor en rekke felt, for eksempel databehandling, vitenskapelige beregninger, maskinlæring og dataanalyse. Innenfor databehandling gjør `np.where()` det mulig å **filtrere data** og erstatte verdier i matriser.

## Hva er syntaksen til np.where i Python?

Funksjonen `np.where()` tar en **NumPy-lignende matrise** som består av for eksempel heltall eller boolske verdier. Syntaksen ser slik ut:

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

- `condition`: Dette er betingelsen som vil bli brukt på matrisen for å bestemme hvilke elementer som skal velges.
- `x` og `y` (valgfritt): Hvis du angir `x` og `y`, vil verdiene fra `x` returneres når betingelsen er oppfylt. Ellers returneres verdiene fra `y`. Hvis du ikke angir `x` og `y`, vil `np.where()` returnere indeksene som oppfyller betingelsen.

Etter utførelse returnerer `np.where()` en **ny NumPy-matrise**. Den nye matrisen er resultatet av filtrering eller valg av elementer fra den opprinnelige matrisen basert på betingelsen.

## Eksempler på hvordan man bruker np.where

`np.where()` er et allsidig verktøy for å bruke betingelser på matriser og er veldig nyttig for datamanipulering. Nedenfor ser vi på noen eksempler på hvordan den kan brukes.

### Erstatt elementer i en NumPy-matrise

Funksjonen `np.where()` i NumPy gjør det mulig å erstatte elementer i en matrise basert på en betingelse. Før du begynner, kan du endre Python-lister til matriser ved hjelp av `np.array()`.

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

Nå som vi har vår matrise, ønsker vi å definere en betingelse for å identifisere elementer som er større enn 3. Vi kan gjøre dette med en betingelse som er `True` for elementer som er større enn 3 og ellers falsk:

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

Deretter bruker vi `np.where()` og legger inn denne betingelsen. Vi fastsetter også at verdier som oppfyller betingelsen skal erstattes med -1, og at alle andre verdier skal erstattes med 0.

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

Resultatet, `new_arr`, inneholder matrisen som er endret basert på betingelsen. I utdataene erstattes verdier som er større enn 3 med -1. Alle andre verdier erstattes med 0.

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

### Bruk np.where med én enkelt betingelse

Hvis du bruker `np.where()` med bare én betingelse og uten erstatningsverdier, vil det returnere en **tuple med indekser** som betingelsen er sann for.

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

I dette eksemplet er `arr` en NumPy-matrise som inneholder verdier fra 1 til 5. `condition = arr > 2` oppretter en boolsk maske som identifiserer elementer i `arr` som er større enn 2. `np.where(condition)` utføres uten erstatningsverdier og returnerer som resultat en tuple med indekser som oppfyller betingelsen `arr > 2`. Utdataene er en matrise med indekser der elementene er større enn 2.

### Kringkasting med np.where

I NumPy gjør kringkasting det mulig å utføre operasjoner med matriser av forskjellig form, forutsatt at visse betingelser er oppfylt. Når matriser har forskjellig form, vil NumPy prøve å forstørre dem slik at de blir kompatible.

La oss si at vi har en NumPy-matrise `arr` med formen (3, 3):

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

Og vi har en annen NumPy-matrise `row` med formen (3,):

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

Formene på de to matrisene stemmer ikke helt overens, men kringkasting kan brukes til å muliggjøre operasjoner mellom dem. Hvis vi for eksempel ønsket å legge sammen verdiene fra hver rad i `arr` med verdiene i `row`, ville kringkasting gjøre dette mulig.

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

I eksemplet ovenfor ble den endimensjonale matrisen `row` forstørret til en (3, 3) matrise for å matche formen til `arr`. Deretter ble elementene i `arr` og `row` lagt sammen element for element.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-npwhere-metoden/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-npwhere-metoden/) for AI/LLM consumption.