# Hvad er np.where i Python?

Du kan bruge funktionen `np.where()` til at arbejde med NumPy-arrays i Python. Dens vektoriserede operationer gør den mere effektiv end loop-baserede metoder.

## Hvad gør np.where?

Python-funktionen `np.where()` er en kraftfuld metode fra NumPy-biblioteket og bruges til at vælge elementer fra en matrix. Den identificerer og udtrækker elementer, der **opfylder en bestemt betingelse**, og returnerer derefter indekser eller værdier, der svarer til denne betingelse.

Funktionen bruges inden for en række forskellige områder, såsom databehandling, videnskabelige beregninger, maskinlæring og dataanalyse. I databehandling gør `np.where()` det muligt at **filtrere data** og erstatte værdier i arrays.

## Hvad er syntaksen for np.where i Python?

Funktionen `np.where()` tager en **NumPy-lignende matrix**, der består af for eksempel heltal eller boolske værdier. Dens syntaks ser således ud:

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

- `condition`: Dette er den betingelse, der vil blive anvendt på arrayet for at bestemme, hvilke elementer der skal vælges.
- `x` og `y` (valgfrit): Hvis du angiver `x` og `y`, returneres værdierne fra `x`, når betingelsen er opfyldt. Ellers returneres værdierne fra `y`. Hvis du ikke angiver `x` og `y`, returnerer `np.where()` de indekser, der opfylder betingelsen.

Efter udførelse returnerer `np.where()` en **ny NumPy-matrix**. Den nye matrix er resultatet af filtrering eller udvælgelse af elementer fra den oprindelige matrix baseret på betingelsen.

## Eksempler på brug af np.where

`np.where()` er et alsidigt værktøj til at anvende betingelser på arrays og er meget nyttigt til databehandling. Nedenfor ser vi på nogle eksempler på, hvordan man bruger det.

### Erstat elementer i en NumPy-matrix

Funktionen `np.where()` i NumPy gør det muligt at erstatte elementer i en matrix baseret på en betingelse. Inden du går i gang, kan du ændre Python-lister til matricer ved hjælp af `np.array()`.

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

Nu hvor vi har vores array, vil vi definere en betingelse for at identificere elementer, der er større end 3. Det kan vi gøre med en betingelse, der er `True` for elementer, der er større end 3, og ellers falsk:

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

Dernæst bruger vi `np.where()` og indtaster denne betingelse. Vi fastslår også, at værdier, der opfylder betingelsen, erstattes med -1, og alle andre værdier erstattes med 0.

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

Resultatet, `new_arr`, indeholder den matrix, der er blevet ændret på baggrund af betingelsen. I outputtet erstattes værdier, der er større end 3, med -1. Alle andre værdier erstattes med 0.

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

### Brug np.where med en enkelt betingelse

Hvis du bruger `np.where()` med kun én betingelse og uden erstatningsværdier, returneres en **tuple med indekser**, som betingelsen er sand 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 eksempel er `arr` en NumPy-matrix, der indeholder værdier fra 1 til 5. `condition = arr > 2` opretter en boolsk maske, der identificerer elementer i `arr`, der er større end 2. `np.where(condition)` udføres uden erstatningsværdier og returnerer derfor en tuple af indekser, der opfylder betingelsen `arr > 2`. Outputtet er en matrix af indekser, hvor elementerne er større end 2.

### Broadcast med np.where

I NumPy gør broadcasting det muligt at udføre operationer med arrays i forskellige former, forudsat at visse betingelser er opfyldt. Når arrays har forskellige former, vil NumPy forsøge at forstørre dem, så de bliver kompatible.

Lad os sige, at vi har en NumPy-matrix `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 anden NumPy-matrix `row` med formen (3,):

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

De to arrays’ former passer ikke helt sammen, men broadcasting kan bruges til at muliggøre operationer mellem dem. Hvis vi f.eks. ønskede at lægge værdierne fra hver række i `arr` sammen med værdierne i `row`, ville broadcasting gøre det muligt.

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

I eksemplet ovenfor blev den endimensionelle matrix `row` udvidet til en (3, 3) matrix for at matche formen af `arr`. Derefter blev elementerne i `arr` og `row` lagt sammen element for element.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-npwhere-metode/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-npwhere-metode/) for AI/LLM consumption.