Python List Comprehension map filter: Einfach erklärt mit Beispielen

Stell dir vor: Du bekommst im Betrieb eine Liste mit 500 Messwerten und sollst alle Werte über 20 herausfiltern und auf ganze Zahlen runden. Mit einer klassischen for-Schleife brauchst du dafür fünf Zeilen Code - mit einer List Comprehension nur eine einzige. Diese Schreibweise gehört zu den wichtigsten Werkzeugen in Python, egal ob du dich als Fachinformatiker-Azubi auf die IHK-Abschlussprüfung vorbereitest, im Studium Programmieraufgaben löst oder im ersten Job fremden Code lesen musst.

Python List Comprehension, `map()` und `filter()` lösen dabei alle dasselbe Problem: Daten in Listen transformieren und filtern. Hier lernst du, wie jedes Werkzeug funktioniert und wann du welches nutzt.

Was ist eine List Comprehension in Python?

Eine List Comprehension ist eine kompakte Schreibweise, um aus einer bestehenden Liste in einer einzigen Zeile eine neue Liste zu erzeugen - mit optionalem Filter. Die offizielle Syntax dokumentiert Python im Python-Tutorial zu Data Structures.

neue_liste = [ausdruck for element in quelle]

Stell dir ein Fließband in einer Fabrik vor: Jedes Element deiner Liste läuft durch, wird bearbeitet und kommt am Ende verändert wieder heraus. Ein Vergleich macht den Vorteil deutlich - zuerst die klassische Schleife:

quadrate = []
for zahl in range(1, 6):
    quadrate.append(zahl * zahl)
print(quadrate)  # [1, 4, 9, 16, 25]

Und jetzt dieselbe Logik als List Comprehension:

quadrate = [zahl * zahl for zahl in range(1, 6)]
print(quadrate)  # [1, 4, 9, 16, 25]

Vier Zeilen werden zu einer - ohne dass sich das Ergebnis ändert. Genau deshalb sieht man diese Schreibweise in Prüfungen, Übungsblättern und echten Projekten ständig. Wenn du Listen generell noch einmal auffrischen willst, wirf einen Blick in unseren Beitrag zu Listen in Python.

Wie filterst du mit einer Bedingung?

Eine List Comprehension filtert automatisch, sobald du ein `if` anhängst. Das ist wie ein Pförtner am Fließband: Nur Elemente, die die Bedingung erfüllen, kommen durch.

zahlen = [3, 12, 7, 25, 9, 40]
grosse_zahlen = [z for z in zahlen if z >= 10]
print(grosse_zahlen)  # [12, 25, 40]

Transformieren und Filtern lassen sich auch kombinieren:

ergebnis = [z * 2 for z in zahlen if z % 2 == 0]
print(ergebnis)  # [24, 80]

Merke: List Comprehensions können gleichzeitig transformieren und filtern - `map()` und `filter()` können jeweils nur eines davon.

Was macht map() in Python?

map() ist eine eingebaute Funktion, die eine übergebene Funktion auf jedes Element einer Liste anwendet und das Ergebnis als Iterator zurückgibt. Die offizielle Python-Dokumentation beschreibt genau dieses Verhalten.

Kern: `map(funktion, quelle)` wendet `funktion` auf jedes Element an und liefert einen Iterator - mit `list()` bekommst du eine echte Liste.

namen = ["anna", "bernd", "clara"]
gross = list(map(str.upper, namen))
print(gross)  # ['ANNA', 'BERND', 'CLARA']

Häufig brauchst du aber eine eigene Rechenregel statt einer fertigen Funktion wie `str.upper`. Dafür eignet sich eine Lambda-Funktion, also eine kleine Funktion ohne Namen - mehr dazu in unserem Artikel zur Python Lambda Funktion:

preise = [10, 25, 40]
mit_mwst = list(map(lambda p: p * 1.19, preise))
print(mit_mwst)  # [11.9, 29.75, 47.6]

Was macht filter() in Python?

filter() behält nur die Elemente einer Liste, für die die übergebene Funktion `True` liefert. Auch hier liefert die Python-Dokumentation zu filter() die Referenz.

zahlen = [3, 12, 7, 25, 9, 40]
grosse_zahlen = list(filter(lambda z: z >= 10, zahlen))
print(grosse_zahlen)  # [12, 25, 40]

Beide Funktionen zusammen verkettet sähe so aus - und hier siehst du schon, warum das unübersichtlich wird:

ergebnis = list(map(lambda z: z * 2, filter(lambda z: z % 2 == 0, zahlen)))
print(ergebnis)  # [24, 80]

Dasselbe Ergebnis liefert die List Comprehension von oben (`[z * 2 for z in zahlen if z % 2 == 0]`) - deutlich lesbarer.

List Comprehension vs. map() und filter(): Der Vergleich

Merke: In den meisten Fällen ist die List Comprehension die pythonischere Wahl - `map()` lohnt sich vor allem, wenn bereits eine benannte Funktion existiert, die du direkt übergeben kannst.

Praxisbeispiel: Messwerte auswerten

Hier ein vollständiges, lauffähiges Skript, wie es dir in Ausbildung, Studium oder Beruf begegnen könnte - etwa bei der Auswertung von Sensordaten:

messwerte = [21.4, 18.9, 25.0, 30.2, 17.5, 28.7, 22.1]

# Nur Werte ueber 20 behalten und runden
kritische_werte = [round(w) for w in messwerte if w > 20]
print(kritische_werte)  # [21, 25, 30, 29, 22]

# Durchschnitt der gefilterten Werte berechnen
durchschnitt = sum(kritische_werte) / len(kritische_werte)
print(durchschnitt)  # 25.4

# Klassifizierung mit if/else innerhalb der Comprehension
labels = ["hoch" if w >= 25 else "okay" for w in kritische_werte]
print(labels)  # ['okay', 'hoch', 'hoch', 'hoch', 'okay']

Beachte den Unterschied beim `if`: Als Filter steht es am Ende (hinter dem `for`), als Fallunterscheidung mit `else` steht es am Anfang (vor dem `for`). Beides in einem Ausdruck geht - wie im Skript oben gezeigt.

Diese 3 Fehler machst du als Anfänger wahrscheinlich

Fehler 1: map() und filter() ohne list() ausgeben

`map()` und `filter()` liefern kein lesbares Ergebnis, sondern nur ein Iterator-Objekt. Im `print` erscheint deshalb etwas wie `<map object at 0x...>`:

# Falsch: Ausgabe ist unleserlich
print(map(str.upper, ["anna", "bernd"]))

# Richtig: explizit in eine Liste umwandeln
print(list(map(str.upper, ["anna", "bernd"])))

Fehler 2: Ein Iterator ist nur einmal nutzbar

Das map-Objekt ist ein Iterator - wer einmal durchgelaufen ist, ist leer. Der zweite Durchlauf liefert also nichts mehr. Warum? Weil Iteratoren ihren Zustand "verbrauchen", wie ein Kassenbon, der beim Einlesen ungültig wird. Details dazu findest du in unserem Beitrag zu Iterable und Iterator in Python.

ergebnis = map(str.upper, ["a", "b"])
print(list(ergebnis))  # ['A', 'B']
print(list(ergebnis))  # [] -- schon verbraucht!

Fehler 3: List Comprehensions für Nebenwirkungen missbrauchen

# Schlechter Stil: Comprehension nur fuer print-Ausgaben
[print(z) for z in zahlen]

Das funktioniert, ist aber schlechter Stil. List Comprehensions sind dafür da, Listen zu erzeugen - nicht, um etwas auszugeben. Für reine Ausgaben nutze die normale for-Schleife. Genauso gilt: Ab zwei Verschachtelungsebenen wird eine Comprehension schwer lesbar - dann ist die Schleife die bessere Wahl.

Übungstipp: Umwandeln als Trainingsroutine

Nimm dir eine Liste mit den Zahlen 1 bis 20 und löse drei Aufgaben: erst mit einer for-Schleife, dann als List Comprehension, dann mit `map()` und `filter()`. Aufgabe 1: alle geraden Zahlen. Aufgabe 2: alle Zahlen quadriert. Aufgabe 3: nur ungerade Zahlen verdoppelt. Wenn du alle drei Varianten ohne Nachschreiben hinbekommst, sitzt das Muster. Genau solche Transformationsaufgaben eignen sich auch super für handschriftliche Übungen - warum, liest du in Code handschriftlich üben.

FAQ: Häufige Fragen

Was ist der Unterschied zwischen List Comprehension und map/filter?

Die List Comprehension erzeugt direkt eine Liste und kann transformieren und filtern gleichzeitig. `map()` transformiert nur, `filter()` filtert nur - und beide geben einen Iterator zurück, den du erst mit `list()` in eine Liste umwandeln musst.

Ist List Comprehension schneller als eine for-Schleife?

Ja, in der Regel minimal schneller, weil Python den Listenaufbau intern optimiert. Der Geschwindigkeitsunterschied ist aber meist so klein, dass du die Lesbarkeit entscheiden lassen solltest - nicht die Mikrosekunden.

Wann nutze ich map() statt einer List Comprehension?

Wenn bereits eine benannte Funktion existiert, die exakt passt - etwa `str.upper` oder eine eigene Funktion `formatiere_preis`. Dann ist `map(formatiere_preis, preise)` kürzer als `[formatiere_preis(p) for p in preise]`.

Kann eine List Comprehension ein if/else enthalten?

Ja, aber die Position entscheidet: `[z * 2 if z > 0 else 0 for z in werte]` ist eine Fallunterscheidung pro Element (steht vor dem `for`), während `[z for z in werte if z > 0]` Elemente herausfiltert (steht nach dem `for`).

Gibt es Comprehensions auch für andere Datentypen?

Ja - für Dictionarys (`{k: v for ...}`) und Sets (`{x for ...}`). Mehr dazu findest du in unserem Artikel zum Python Dictionary und im Überblick über Python Collections.

Fazit

List Comprehension, `map()` und `filter()` lösen alle dasselbe Problem auf unterschiedliche Weise. Die Faustregel ist einfach: List Comprehension als Standard, `map()` und `filter()`, wenn bereits passende Funktionen existieren oder du bewusst mit Iteratoren arbeitest. Wenn du diese drei Werkzeuge beherrschst, kannst du typische Datenaufgaben in Python in einer Zeile lösen - eine Fähigkeit, die dir in Prüfung, Studium und Beruf gleichermaßen weiterhilft.

Wenn du bei Python-Themen wie diesen individuell Unterstützung brauchst, schau dir unsere Nachhilfe bei study-it.education an. Wir begleiten Azubis, Studenten und Berufseinsteiger - vom ersten Listen-Code bis zur Abschlussprüfung.