List Comprehensions: Eleganter Python-Code

Eine der schönsten Eigenschaften von Python ist, dass sich viele Aufgaben sehr kompakt ausdrücken lassen. Ein Paradebeispiel dafür sind List Comprehensions. Statt eine leere Liste anzulegen und sie in einer Schleife Stück für Stück zu füllen, erzeugst du eine neue Liste in einer einzigen, gut lesbaren Zeile. In diesem Beitrag lernst du Schritt für Schritt, wie List Comprehensions funktionieren, wie du sie mit Bedingungen kombinierst und wann sie wirklich sinnvoll sind.

Vom klassischen Loop zur Comprehension

Schauen wir uns zuerst die klassische Variante an: Wir wollen eine Liste mit den Quadratzahlen von 0 bis 4 erzeugen. Mit einer normalen for-Schleife sieht das so aus:

quadrate = []
for zahl in range(5):
    quadrate.append(zahl ** 2)

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

Mit einer List Comprehension schreibst du dasselbe in einer Zeile. Das Grundmuster lautet [ausdruck for element in iterable]:

quadrate = [zahl ** 2 for zahl in range(5)]
print(quadrate)  # [0, 1, 4, 9, 16]

Beide Varianten liefern dasselbe Ergebnis. Die Comprehension ist aber kürzer und drückt die Absicht "erzeuge für jede Zahl ihr Quadrat" direkt aus.

Filtern mit einer Bedingung

Oft willst du nicht alle Elemente übernehmen, sondern nur bestimmte. Dafür hängst du am Ende ein if an. Das Muster wird zu [ausdruck for element in iterable if bedingung]. Hier filtern wir nur die geraden Zahlen heraus:

zahlen = range(10)
gerade = [z for z in zahlen if z % 2 == 0]
print(gerade)  # [0, 2, 4, 6, 8]

woerter = ["Apfel", "Ei", "Banane", "Uhr"]
lange = [w for w in woerter if len(w) > 3]
print(lange)  # ['Apfel', 'Banane']

Die Bedingung entscheidet, ob ein Element überhaupt in die neue Liste aufgenommen wird. Das ist eine sehr saubere Art, Daten zu filtern.

Werte gleichzeitig umformen

Das Schöne an Comprehensions ist, dass du Filtern und Umformen kombinieren kannst. Du wählst aus, welche Elemente du behalten willst, und veränderst sie gleichzeitig. Hier nehmen wir nur die positiven Werte und verdoppeln sie:

werte = [-3, 5, -1, 8, 0, 12]
positiv_doppelt = [w * 2 for w in werte if w > 0]
print(positiv_doppelt)  # [10, 16, 24]

namen = ["anna", "BERND", "Clara"]
sauber = [n.capitalize() for n in namen]
print(sauber)  # ['Anna', 'Bernd', 'Clara']

Im zweiten Beispiel vereinheitlichen wir die Schreibweise aller Namen in einer Zeile. So entstehen aus Rohdaten schnell saubere, einheitliche Listen.

Bedingung im Ausdruck: if/else

Es gibt einen wichtigen Unterschied: Ein if am Ende filtert Elemente heraus. Ein if/else vorne im Ausdruck wählt dagegen für jedes Element zwischen zwei Werten – es wird kein Element entfernt. Das ist ein häufiger Stolperstein:

zahlen = [1, 2, 3, 4, 5]

# if am Ende: filtert (nur gerade bleiben)
nur_gerade = [z for z in zahlen if z % 2 == 0]
print(nur_gerade)  # [2, 4]

# if/else im Ausdruck: ersetzt jedes Element
beschriftung = ["gerade" if z % 2 == 0 else "ungerade" for z in zahlen]
print(beschriftung)
# ['ungerade', 'gerade', 'ungerade', 'gerade', 'ungerade']

Merke dir: Steht das if hinter dem for, filtert es. Steht ein if/else vor dem for, transformiert es jedes Element.

Auch für Dictionaries und Sets

Das Konzept funktioniert nicht nur für Listen. Mit geschweiften Klammern erzeugst du Dictionary Comprehensions und Set Comprehensions. Das spart dir auch hier viel Schreibarbeit:

# Dictionary Comprehension
zahlen = [1, 2, 3, 4]
quadrate = {z: z ** 2 for z in zahlen}
print(quadrate)  # {1: 1, 2: 4, 3: 9, 4: 16}

# Set Comprehension (entfernt Duplikate automatisch)
buchstaben = {c for c in "banane"}
print(buchstaben)  # {'b', 'a', 'n', 'e'}

Achte bei Dictionary Comprehensions auf das Muster {schluessel: wert for ...} mit Doppelpunkt. Bei Sets gibt es keinen Doppelpunkt, und doppelte Werte fallen automatisch weg.

Fazit

List Comprehensions sind ein Markenzeichen von elegantem Python-Code. Du hast gelernt, wie du aus einer klassischen Schleife eine kompakte Comprehension machst, wie du mit if filterst, Werte umformst und den Unterschied zwischen filterndem if und auswählendem if/else verstehst. Auch Dictionaries und Sets lassen sich auf dieselbe Weise erzeugen. Ein Hinweis zum Schluss: So mächtig Comprehensions sind, übertreibe es nicht. Wenn die Logik zu verschachtelt wird, ist eine normale Schleife oft besser lesbar. Setze Comprehensions also dort ein, wo sie deinen Code wirklich klarer machen.