Was sind List Comprehensions?

Question

IT Interview Practice · Accepted Answer

Eine **list comprehension** ist eine prägnante und lesbare Möglichkeit, eine Liste zu erstellen, indem ein iterables Element in einem einzelnen Ausdruck transformiert und/oder gefiltert wird — Pythons idiomatische Alternative zu einer `for`-Schleife, die an eine Liste anfügt.

## Grundlegende Syntax

```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───┘
```

Lesen Sie es als "das Quadrat von n, für jedes n in range(5)." Es ist prägnanter und oft schneller als die manuelle Schleife.

## Filter hinzufügen (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]
```

## Bedingter Ausdruck in der Ausgabe

```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"]
```

## Comprehensions für andere Typen

```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
```

Die gleiche Syntax erstellt Sets und Dicts; mit Klammern wird sie zu einem **generator expression**, das Werte faul erzeugt (keine vollständige Liste im Speicher — großartig für große Daten).

## Wann man sie NICHT verwendet

```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
```

Halten Sie Comprehensions einfach; wenn sie mehrere verschachtelte Schleifen oder komplexe Bedingungen benötigen, ist eine gewöhnliche Schleife klarer.

## Warum es wichtig ist

List Comprehensions sind quintessentiell "pythonisch" — prägnant, lesbar und oft schneller als gleichwertige Schleifen, ständig zum Transformieren und Filtern von Daten verwendet.

Sie zu beherrschen (plus ihre set/dict/generator-Varianten und lazy generator expression für große Daten) ist unerlässlich für das Schreiben von idiomatischem Python.

Zu wissen, wann man sie verwendet (einfache Transformationen/Filter) versus eine reguläre Schleife (komplexe Logik), ist das Merkmal von sauberen, lesbaren Code.

Grundlegende Syntax

Filter hinzufügen (if)

Bedingter Ausdruck in der Ausgabe

Comprehensions für andere Typen

Wann man sie NICHT verwendet

Warum es wichtig ist

Ähnliche Fragen