List Comprehensions in Python: Kompakter Code für Listen

Wenn du in Python eine neue Liste aus einer bestehenden erzeugen willst, greifst du am Anfang meist zur klassischen for-Schleife. Das funktioniert, ist aber oft umständlich. List Comprehensions sind Pythons elegante Antwort darauf: Sie bauen Listen in einer einzigen, gut lesbaren Zeile. In diesem Beitrag lernst du die Syntax Schritt für Schritt kennen, wie du Bedingungen einbaust und wann du lieber doch zur normalen Schleife greifst.

Was ist eine List Comprehension?

Eine List Comprehension ist eine kompakte Schreibweise, um eine Liste zu erstellen. Statt eine leere Liste anzulegen und sie in einer Schleife mit append() zu füllen, beschreibst du direkt, was in der Liste stehen soll. Schau dir zuerst die klassische Variante an:

zahlen = [1, 2, 3, 4, 5]
quadrate = []
for n in zahlen:
    quadrate.append(n * n)

print(quadrate)  # [1, 4, 9, 16, 25]

Vier Zeilen für eine eigentlich simple Idee. Mit einer List Comprehension wird daraus ein einziger, klar lesbarer Ausdruck.

Die Grundsyntax

Eine List Comprehension steht immer in eckigen Klammern und folgt dem Muster [ausdruck for element in iterable]. Der ausdruck vorne beschreibt, was mit jedem Element passieren soll:

zahlen = [1, 2, 3, 4, 5]
quadrate = [n * n for n in zahlen]

print(quadrate)  # [1, 4, 9, 16, 25]

Du liest das fast wie einen englischen Satz: nimm n * n für jedes n in zahlen. Das funktioniert mit jedem iterierbaren Objekt – auch mit range() oder Strings:

grossbuchstaben = [zeichen.upper() for zeichen in "hallo"]
print(grossbuchstaben)  # ['H', 'A', 'L', 'L', 'O']

verdoppelt = [x * 2 for x in range(5)]
print(verdoppelt)  # [0, 2, 4, 6, 8]

Bedingungen mit if

Oft willst du nicht alle Elemente übernehmen, sondern nur bestimmte. Dafür hängst du ein if ans Ende. Hier filterst du zum Beispiel nur die geraden Zahlen heraus:

zahlen = range(1, 11)
gerade = [n for n in zahlen if n % 2 == 0]

print(gerade)  # [2, 4, 6, 8, 10]

Das if am Ende wirkt als Filter: Nur Elemente, für die die Bedingung True ergibt, landen in der neuen Liste. Du kannst Filtern und Umwandeln auch kombinieren:

woerter = ["Apfel", "Ei", "Banane", "Uhr", "Computer"]
lange = [w.lower() for w in woerter if len(w) > 3]

print(lange)  # ['apfel', 'banane', 'computer']

if/else im Ausdruck

Es gibt noch eine zweite Stelle, an der ein if auftauchen kann – und die wird gern verwechselt. Wenn du nicht filtern, sondern für jedes Element entscheiden willst, kommt das if/else nach vorne in den Ausdruck:

zahlen = [1, 2, 3, 4, 5, 6]
labels = ["gerade" if n % 2 == 0 else "ungerade" for n in zahlen]

print(labels)
# ['ungerade', 'gerade', 'ungerade', 'gerade', 'ungerade', 'gerade']

Die Faustregel: Steht das if hinten (ohne else), filtert es Elemente heraus. Steht ein if/else vorne, wählt es für jedes Element einen Wert. Beides zu mischen ist möglich, macht den Code aber schnell schwer lesbar.

Verschachtelte Comprehensions

Du kannst auch über mehrere Ebenen iterieren, etwa um eine verschachtelte Liste flach zu machen. Die for-Teile werden dabei einfach in der gleichen Reihenfolge geschrieben wie bei normalen Schleifen – von außen nach innen:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flach = [zahl for zeile in matrix for zahl in zeile]

print(flach)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Das entspricht zwei ineinander geschachtelten Schleifen. Mehr als zwei Ebenen solltest du aber selten in eine Comprehension packen – sonst leidet die Lesbarkeit stark.

Dict und Set Comprehensions

Das gleiche Prinzip funktioniert auch für Dictionaries und Sets. Bei einem Dict nutzt du geschweifte Klammern und ein Schlüssel-Wert-Paar mit Doppelpunkt:

woerter = ["Python", "Code", "Reise"]
laengen = {w: len(w) for w in woerter}

print(laengen)  # {'Python': 6, 'Code': 4, 'Reise': 5}

# Set Comprehension: nur eindeutige Werte
zahlen = [1, 2, 2, 3, 3, 3]
eindeutig = {n * n for n in zahlen}
print(eindeutig)  # {1, 4, 9}

So hast du für Listen, Dictionaries und Sets dieselbe kompakte, gut lesbare Syntax zur Hand.

Wann du sie besser nicht verwendest

List Comprehensions sind großartig, aber kein Allheilmittel. Greife lieber zur klassischen Schleife, wenn:

• die Logik komplex ist und mehrere Schritte oder Zwischenvariablen braucht,
• du innerhalb der Schleife Nebeneffekte auslöst (z. B. etwas ausgeben oder in eine Datei schreiben),
• die Comprehension so lang wird, dass sie über mehrere Zeilen umbricht und niemand sie auf einen Blick versteht.

Comprehensions sind dafür gedacht, aus Daten neue Daten zu erzeugen. Sobald es eher um einen Ablauf von Aktionen geht, ist eine normale for-Schleife die klarere Wahl.

Fazit

List Comprehensions verwandeln mehrzeilige Schleifen in kurze, ausdrucksstarke Einzeiler. Du kennst jetzt die Grundsyntax, das Filtern mit einem nachgestellten if, die Auswahl per if/else im Ausdruck, Verschachtelungen sowie Dict- und Set-Comprehensions. Mein Tipp: Setze sie überall dort ein, wo du eine Sammlung in eine andere umformst – aber bleib bei der normalen Schleife, sobald die Lesbarkeit leidet. Lesbarer Code schlägt cleveren Code fast immer.