Hva er listekomprehensjon?

Question

Accepted Answer

En **listekomprehensjon** er en presis og lesbar måte å bygge en liste ved å transformere og/eller filtrere en iterable i et enkelt uttrykk — Pythons idiomatiske alternativ til en `for`-løkke som legger til i en liste.

## Grunnleggende syntaks

```python
# the loop way:
squares = []
for n in range(5):
    squares.append(n ** 2)

# the comprehension way — same result, one line
squares = [n ** 2 for n in range(5)]   # [0, 1, 4, 9, 16]
#          └expr──┘ └──for clause───┘
```

Les det som "kvadratet av n, for hver n i range(5)." Det er mer presis og ofte raskere enn den manuelle løkken.

## Legge til et filter (if)

```python
# keep only even numbers
evens = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]

# transform AND filter together
result = [n * 2 for n in range(10) if n % 2 == 0]  # [0, 4, 8, 12, 16]
```

## Betinget uttrykk i resultatet

```python
# if/else goes BEFORE the for (it's part of the expression, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(4)]
# ["even", "odd", "even", "odd"]
```

## Komprehensjon for andre typer

```python
{x ** 2 for x in range(5)}             # set comprehension → {0, 1, 4, 9, 16}
{k: v for k, v in pairs}               # dict comprehension
(x ** 2 for x in range(5))             # generator expression — LAZY, memory-efficient
```

Den samme syntaksen bygger sets og dicts; med parenteser blir det et **generator-uttrykk** som produserer verdier lat (ingen full liste i minnet — flott for store data).

## Når du IKKE skal bruke dem

```python
# ❌ deeply nested / complex logic → a regular loop is more readable
matrix = [[row[i] for row in data] for i in range(cols)]  # OK, but don't over-nest
```

Hold komprehensioner enkle; hvis de trenger flere nestede løkker eller komplekse betingelser, er en vanlig løkke klarere.

## Hvorfor det er viktig

Listekomprehensioner er typisk "Pythonsk" — presis, lesbar og ofte raskere enn tilsvarende løkker, brukt konstant for å transformere og filtrere data.

Å mestre dem (pluss deres set/dict/generator-varianter, og det late generator-uttrykket for store data) er essensielt for å skrive idiomatisk Python.

Å vite når du skal bruke dem (enkle transformasjoner/filter) versus en vanlig løkke (kompleks logikk) er kjennetegnet på ren, lesbar kode.