Python List Comprehension Tutorial

Wenn du Datenwissenschaft betreibst, möchtest du vielleicht Listen von Listen lesen, Spaltennamen filtern, Vokale aus einer Liste entfernen oder eine Matrix glätten. Du kannst einfach eine Lambda-Funktion oder eine for-Schleife verwenden; wie du weißt, gibt es dafür mehrere Möglichkeiten. Eine andere Möglichkeit, dies zu tun, ist die Verwendung von Listenkomplexen.

In diesem Lernprogramm wird dieses letzte Thema behandelt:

• Zuerst bekommst du einen kurzen Überblick darüber, was Python-Listen sind und wie sie im Vergleich zu anderen Python-Datenstrukturen aussehen;
• Als Nächstes tauchst du in die Python-Listenkomplexe ein: Du erfährst mehr über die Mathematik hinter Python-Listen, wie du Listenkomplexe konstruieren kannst, wie du sie als for-Schleifen oder Lambda-Funktionen umschreiben kannst, .... Du wirst nicht nur darüber lesen, sondern auch ein paar Übungen machen!
• Wenn du die Grundlagen beherrschst, ist es an der Zeit, deine List Comprehensions durch das Hinzufügen von Bedingungen zu verfeinern: Du lernst, wie du Bedingungen in List Comprehensions einfügen kannst und wie du mehrere if-Bedingungen und if-else-Anweisungen handhaben kannst.
• Zum Schluss lernst du verschachtelte Listenverknüpfungen kennen, um mehrfach über Listen zu iterieren.

Wenn du auch daran interessiert bist, List Comprehensions zusammen mit Iteratoren und Generatoren zu behandeln? Schau dir den DataCamp-Kurs Python Data Science Toolbox an!

Python-Listen

Inzwischen hast du wahrscheinlich schon mit Werten gespielt, die mehrere Datentypen haben. Du hast jeden einzelnen Wert in einer eigenen Variable gespeichert: Jede Variable steht für einen einzelnen Wert. In der Datenwissenschaft arbeitest du jedoch oft mit vielen Datenpunkten, so dass es schwierig ist, jeden Wert in einer eigenen Variable zu speichern. Stattdessen speicherst du alle diese Werte in einer Python-Liste.

Listen sind eine der vier eingebauten Datenstrukturen in Python. Andere Datenstrukturen, die du vielleicht kennst, sind Tupel, Wörterbücher und Mengen. Eine Liste in Python unterscheidet sich von z.B. int oder bool in dem Sinne, dass sie ein zusammengesetzter Datentyp ist: Du kannst Werte in Listen zusammenfassen. Diese Werte müssen nicht unbedingt vom gleichen Typ sein: Sie können eine Kombination aus booleschen, String-, Integer-, ... Werten sein.

Es ist wichtig zu wissen, dass Listen geordnete Sammlungen von Gegenständen oder Objekten sind. Das macht Listen in Python zu "Sequenztypen", da sie sich wie eine Sequenz verhalten. Das bedeutet, dass sie iteriert werden können. Andere Beispiele für Sequenzen sind Strings, Tupel oder Sets.

Tipp: Wenn du mehr wissen, dein Wissen über Python-Listen testen oder üben möchtest, kannst du dir hier die häufigsten Fragen zu Python-Listen ansehen.

Nun zur Praxis: Du erstellst eine Liste mit zwei eckigen Klammern; innerhalb dieser Klammern trennst du die Werte mit Kommas. Du kannst deine Liste dann einer Variablen zuweisen. Die Werte, die du in eine Python-Liste einträgst, können von jedem Datentyp sein, auch Listen!

Sieh dir das folgende Beispiel für eine Liste an:

Tipp: Erstelle deine eigene Liste in der IPython-Shell, die in dem obigen DataCamp Light-Baustein enthalten ist!

Python List Comprehension

Wenn du dir die Python-Listen noch einmal vor Augen führst, wird dir schnell klar, dass das Definieren und Erstellen von Listen in Python eine mühsame Arbeit sein kann: Alle Werte einzeln einzutippen, kann ziemlich viel Zeit in Anspruch nehmen und du kannst leicht Fehler machen.

Listenverständnisse in Python sind wie folgt aufgebaut:

list_variable = [x for x in iterable]

Aber wie kommst du zu dieser formelähnlichen Art, diese Konstrukte in Python aufzubauen und zu verwenden? Lass uns ein bisschen tiefer graben.

List Comprehension in Python: Die Mathematik

Zum Glück hat Python die Lösung für dich: Es bietet dir eine Möglichkeit, eine mathematische Notation zu implementieren, um dies zu tun: Listenverständnis.

Erinnere dich daran, dass es in der Mathematik gängige Methoden gibt, um Listen (oder Mengen, Tupel oder Vektoren) zu beschreiben:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

Mit anderen Worten, du wirst feststellen, dass die oben genannten Definitionen dir eigentlich Folgendes sagen:

• Die Folge S ist eigentlich eine Folge, die Werte zwischen 0 und 9 enthält, die mit zwei hochgezählt werden.
• Die Folge V hingegen enthält den Wert 2, der mit einer bestimmten Potenz erhöht wird. Für das erste Element in der Folge ist dies die 0, für das zweite die 1 und so weiter, bis du 12 erreichst.
• Schließlich enthält die Folge M Elemente aus der Folge S, aber nur die geraden.

Wenn dir die obigen Definitionen Kopfschmerzen bereiten, sieh dir die tatsächlichen Listen an, die diese Definitionen ergeben würden:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Du siehst deutlich das Ergebnis jeder Liste und die darin beschriebenen Vorgänge!

Jetzt, wo du die Mathematik hinter den Listen verstanden hast, kannst du die mathematische Notation für den Aufbau von Listen in Python übersetzen oder implementieren, indem du List Comprehensions verwendest! Sieh dir die folgenden Codezeilen an:

Das sieht alles sehr ähnlich aus wie die mathematischen Definitionen, die du gerade gesehen hast, oder?

Keine Sorge, wenn du an dieser Stelle etwas ratlos bist. Auch wenn du kein Mathegenie bist, sind diese Listen recht einfach zu verstehen, wenn du dir die Zeit nimmst, sie zu lernen. Sieh dir den Python-Code, den du im obigen Codeabschnitt siehst, noch einmal genauer an.

Du wirst sehen, dass der Code dir das sagt:

• Die Liste S wird mit den eckigen Klammern aufgebaut, die du oben im ersten Abschnitt gelesen hast. In diesen Klammern siehst du, dass es ein Element x gibt, das zur Potenz von 10 erhoben wird. Jetzt musst du nur noch wissen, für wie viele Werte (und welche Werte!) du auf die Potenz von 2 erhöhen musst. Dies wird in range(10) festgelegt. Aus all dem kannst du ableiten, dass du alle Zahlen von 0 bis 9 zur Potenz von 2 erheben wirst.
• Die Liste V enthält den Basiswert 2, der mit einer bestimmten Potenz erhöht wird. Genau wie zuvor musst du jetzt wissen, welche Leistung oder i genau dafür verwendet wird. Du siehst, dass i in diesem Fall Teil von range(13) ist, was bedeutet, dass du bei 0 beginnst und bis 12 gehst. All das bedeutet, dass deine Liste 13 Werte haben wird - diese Werte sind 2 hoch 0, 1, 2, ... bis hin zu 12.
• Schließlich enthält die Liste M Elemente, die zu S gehören, wenn - und nur wenn - sie durch 2 geteilt werden können, ohne dass Reste übrig bleiben. Das Modulo muss 0 sein. Mit anderen Worten: Die Liste M wird aus den gleichen Werten gebildet, die in der Liste S gespeichert sind.

Jetzt, wo du das alles aufgeschrieben siehst, macht es viel mehr Sinn, oder?

Rekapitulation und Übung

Kurz gesagt, du siehst, dass in all diesen Codezeilen einige Elemente wiederkehren:

• Die eckigen Klammern, die ein Merkmal von Python-Listen sind;
• Das Schlüsselwort for, gefolgt von einer Variablen, die ein Listenelement symbolisiert; und
• Das Schlüsselwort in, gefolgt von einer Sequenz (die eine Liste sein kann!).

Das Ergebnis ist das Stück Code, das du am Anfang dieses Abschnitts gesehen hast:

list_variable = [x for x in iterable]

Jetzt bist du an der Reihe und kannst mit den List Comprehensions in Python loslegen! Halten wir uns an die mathematischen Listen, die du schon gesehen hast:

List Comprehension als Alternative zu...

List comprehension ist ein vollständiger Ersatz für for-Schleifen, Lambda-Funktionen sowie die Funktionen map(), filter() und reduce(). Für manche Menschen kann das Listenverständnis sogar einfacher zu verstehen und in der Praxis anzuwenden sein! Mehr dazu erfährst du im nächsten Abschnitt!

Wenn du jedoch mehr über Funktionen und Lambda-Funktionen in Python wissen möchtest, schau dir unser Python-Funktionen-Tutorial an.

For-Schleifen

Wie du vielleicht schon weißt, benutzt du for-Schleifen, um einen Codeblock eine bestimmte Anzahl von Malen zu wiederholen. List Comprehensions sind eigentlich eine gute Alternative zu for-Schleifen, da sie kompakter sind. Betrachte das folgende Beispiel, das mit der Variable numbers beginnt, die als Bereich von 0 bis 10 definiert ist (nicht eingeschlossen).

Denke daran, dass die Zahl, die du der Funktion range() übergibst, eigentlich die Anzahl der ganzen Zahlen ist, die du erzeugen willst, natürlich beginnend bei Null. Das bedeutet, dass range(10) [0,1,2,3,4,5,6,7,8,9] zurückgeben wird.

# Initialize `numbers`
numbers = range(10)

Wenn du nun eine Operation für jedes Element in numbers durchführen willst, kannst du das mit einer for-Schleife wie dieser hier tun:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Das ist alles schön und gut, aber betrachte nun das folgende Beispiel eines Listenverständnisses, bei dem du im Grunde dasselbe mit einer kompakteren Notation tust:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Untersuchen wir den Leistungsunterschied zwischen dem Listenverständnis und der for-Schleife mit einem kleinen Test: Mit der Bibliothek timeit, mit der du auf einfache Weise kleine Teile deines Python-Codes zeitlich einordnen kannst, kannst du das sehr schnell einrichten. In diesem Fall sind die kleinen Codestücke, die du testen wirst, die for-Schleife, die du der Einfachheit halber in eine Funktion namens power_two() packst, und das genaue Listenverständnis, das du oben formuliert hast.

Beachte, dass du auch die Anzahl der Durchführungen angibst, die du berücksichtigen möchtest. In diesem Fall ist das number Argument auf 10000 gesetzt.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Beachte, dass du in diesem letzten Teil des Codes auch das Argument globals hinzufügst, was dazu führt, dass der Code in deinem aktuellen globalen Namensraum ausgeführt wird. Dies ist besonders praktisch, wenn du eine benutzerdefinierte Funktion (UDF) wie die Funktion power_two() im obigen Beispiel hast. Alternativ kannst du auch einen setup Parameter übergeben, der eine Importanweisung enthält. Mehr darüber kannst du hier lesen.

Tipp: Im DataCamp-Tutorial " Schleifen in Python " findest du weitere Informationen zu Schleifen in Python.

Lambda-Funktionen mit map(), filter() und reduce()

Lambda-Funktionen werden auch "anonyme Funktionen" oder "Funktionen ohne Namen" genannt. Das bedeutet, dass du diese Art von Funktionen nur verwendest, wenn sie erstellt werden. Lambda-Funktionen haben ihren Namen von dem Schlüsselwort lambda in Python, das zur Deklaration dieser Funktionen anstelle des Standardschlüsselworts def verwendet wird.

Du verwendest diese Funktionen normalerweise zusammen mit den Funktionen map(), filter() und reduce().

Wie man ersetzt map() in Kombination mit Lambda-Funktionen

Du kannst die Kombination map() und eine Lambda-Funktion genau wie im folgenden Beispiel umschreiben:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Jetzt kannst du diese Kombination von Funktionen, die die Variable feet definieren, ganz einfach durch List Comprehensions ersetzen, indem du die Komponenten berücksichtigst, über die du im vorherigen Abschnitt gelesen hast:

• Beginne mit den eckigen Klammern.
• Füge dann den Körper der Lambda-Funktion in die eckigen Klammern ein: float(3280.8399)*x.
• Als Nächstes fügst du das Schlüsselwort for hinzu und stellst sicher, dass du das Sequenzelement x wiederholst, auf das du bereits durch Hinzufügen des Körpers der Lambda-Funktion verwiesen hast.
• Vergiss nicht, anzugeben, woher x kommt: Füge das Schlüsselwort in hinzu, gefolgt von der Sequenz, aus der du x erhalten willst. In diesem Fall wirst du die Elemente der Liste kilometer umwandeln.

Wenn du all dies tust, erhältst du das folgende Ergebnis:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() und Lambda-Funktionen zu List Comprehensions

Nachdem du nun gesehen hast, wie einfach du die Funktion map() in Kombination mit einer Lambda-Funktion umwandeln kannst, kannst du auch Code, der die Python-Funktion filter() mit Lambda-Funktionen enthält, in Angriff nehmen und diesen ebenfalls umschreiben.

Betrachte das folgende Beispiel:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Um die Codezeilen im obigen Beispiel umzuschreiben, kannst du eigentlich zwei Listenversteher verwenden, die sowohl in den Variablen feet als auch uneven gespeichert sind.

Zuerst schreibst du die Funktion map() um, mit der du die Elemente der Liste feet in ganze Zahlen umwandelst. Dann gehst du die Funktion filter() an: Du nimmst den Körper der Lambda-Funktion und verwendest die Schlüsselwörter for und in, um x und feet logisch zu verbinden:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Reduziere reduce() und Lambda-Funktionen in Python

Schließlich kannst du auch Lambda-Funktionen, die mit der Funktion reduce() verwendet werden, in kompaktere Codezeilen umschreiben. Sieh dir das folgende Beispiel an:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Beachte, dass die Funktion reduce() in Python 3 in das Paket functools verschoben wurde. Daher musst du das Modul importieren, um es zu verwenden, genau wie im Codebeispiel oben.

Der obige Codeabschnitt ist ziemlich lang, oder?

Lass uns dieses Stück Code neu schreiben!

Sei vorsichtig! Du musst bedenken, dass du y nicht verwenden kannst. List comprehensions funktionieren nur mit einem einzigen Element, wie z.B. x, das du in den vielen Beispielen dieses Tutorials gesehen hast.

Wie willst du das lösen?

In solchen Fällen können Aggregationsfunktionen wie sum() sehr nützlich sein:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Wenn du darüber nachdenkst, macht die Verwendung von Aggregationsfunktionen beim Umschreiben der Funktion reduce() in Kombination mit einer Lambda-Funktion Sinn: Es ist sehr ähnlich zu dem, was du in SQL machst, wenn du Aggregationsfunktionen verwendest, um die Anzahl der Datensätze zu begrenzen, die du nach der Ausführung deiner Abfrage zurückbekommst. In diesem Fall verwendest du die Funktion sum(), um die Elemente in feet zu aggregieren und nur einen endgültigen Wert zu erhalten!

Auch wenn dieser Ansatz in SQL vielleicht nicht so performant ist, ist er in Python definitiv der richtige Weg!

Listenkomplexe mit Konditionalen

Jetzt, wo du die Grundlagen der List Comprehensions in Python verstanden hast, ist es an der Zeit, den Kontrollfluss deiner Comprehensions mit Hilfe von Conditionals anzupassen.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Beachte, dass du den obigen Code einfach mit einer Python for-Schleife umschreiben kannst!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Mehrere Wenn-Bedingungen

Nachdem du nun verstanden hast, wie du Bedingungen hinzufügen kannst, ist es an der Zeit, die folgende for-Schleife in eine Listenverarbeitung mit Bedingungen umzuwandeln.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Sei vorsichtig, du siehst, dass die folgende for-Schleife zwei Bedingungen enthält! Überlege dir genau, wie du das Problem lösen willst.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

Wenn-Else-Bedingungen

Natürlich ist es viel üblicher, mit Konditionalen zu arbeiten, die mehr als eine Bedingung beinhalten. Das stimmt, du wirst if häufiger in Kombination mit elif und else sehen. Wie gehst du damit um, wenn du vorhast, deinen Code neu zu schreiben?

Sieh dir das folgende Beispiel für eine solche komplexere Bedingung in einer for-Schleife an:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Sieh dir nun den folgenden Code an, der eine Neufassung des obigen Codes ist:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Du siehst, dass dies im Grunde derselbe Code ist, aber umstrukturiert: Das letzte for x in feet initialisiert jetzt die for-Schleife. Danach fügst du die Bedingung if x >= 120000 und die Codezeile hinzu, die du ausführen willst, wenn diese Bedingung True: x + 1 ist. Wenn die Bedingung stattdessen False lautet, wird das letzte Stück Code in deinem Listenverständnis ausgeführt: x+5.

Verschachtelte Listenkomplexe

Abgesehen von den Konditionalen kannst du deine List Comprehensions auch anpassen, indem du sie innerhalb anderer List Comprehensions verschachtelst. Das ist praktisch, wenn du mit Listen von Listen arbeiten willst: Das Erzeugen von Listen von Listen, das Transponieren von Listen von Listen oder das Verflachen von Listen von Listen zu regulären Listen wird zum Beispiel mit verschachtelten Listenverstehern extrem einfach.

Sieh dir das folgende Beispiel an:

list_of_list = [[1,2,3],[4,5,6],[7,8]]

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

[1, 2, 3, 4, 5, 6, 7, 8]

Du ordnest einer Variablen list_of_list eine recht einfache Liste von Listen zu. In der nächsten Zeile führst du eine List Comprehension aus, die eine normale Liste zurückgibt. Was tatsächlich passiert, ist, dass du die Listenelemente ( y ) der verschachtelten Listen ( x ) in list_of_list nimmst und eine Liste derjenigen Listenelemente y zurückgibst, die in x enthalten sind.

Du siehst, dass die meisten Schlüsselwörter und Elemente, die im Beispiel für das verschachtelte Listenverständnis verwendet werden, denen ähneln, die du in den Beispielen für das einfache Listenverständnis verwendet hast:

• Eckige Klammern
• Zwei for Schlüsselwörter, gefolgt von einer Variablen, die ein Listenelement (x) und ein Listenelement einer verschachtelten Liste (y) symbolisiert; Und
• Zwei in Schlüsselwörter, gefolgt von einer Liste von Listen (list_of_list) und einem Listenelement (x).

Die meisten Komponenten werden einfach doppelt verwendet und du gehst eine Ebene höher (oder tiefer, je nachdem, wie du es betrachtest!).

Es braucht etwas Zeit, um sich daran zu gewöhnen, aber es ist ziemlich einfach, oder?

In einem anderen Beispiel siehst du, dass du auch zwei Paare eckiger Klammern verwenden kannst, um die Logik deines verschachtelten Listenverständnisses zu ändern:

matrix = [[1,2,3],[4,5,6],[7,8,9]]

[[row[i] for row in matrix] for i in range(3)]

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Nun zur Übung: Schreibe den obigen Codebrocken in eine verschachtelte for-Schleife um. Wenn du ein paar Tipps brauchst, wie du diese Übung angehen kannst, schau dir einen der vorherigen Abschnitte dieses Lehrgangs an.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Du kannst auch verschachtelte Listenkomplexe verwenden, wenn du eine Liste von Listen erstellen musst, die eigentlich eine Matrix ist. Schau dir das folgende Beispiel an:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Tipp: Übe deine Schleifenfähigkeiten in Python und schreibe den obigen Codebrocken in eine verschachtelte for-Schleife um!

Du kannst die Lösung unten finden.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Wenn du etwas mehr Arbeit haben willst, kannst du diese for-Schleife in eine while-Schleife umwandeln. Du kannst die Lösung unten finden:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Zu guter Letzt ist es gut zu wissen, dass du auch Funktionen wie int() verwenden kannst, um die Einträge in deiner feet Liste in ganze Zahlen umzuwandeln. Indem du [int(x) for x in feet] in ein anderes Listenverständnis kapselst, kannst du ganz einfach eine Matrix oder Listen deiner Liste erstellen:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Meistere Python für Data Science

Herzlichen Glückwunsch! Du hast es bis zum Ende dieses Tutorials geschafft, in dem du dich mit List Comprehensions beschäftigt hast, einem Mechanismus, der in Python häufig für Data Science verwendet wird. Jetzt, wo du die Funktionsweise dieses Mechanismus verstehst, bist du bereit, auch Wörterbuch-, Mengen-, ... Verständnisse in Angriff zu nehmen!

Vergiss nicht, dass du deine Python-Kenntnisse mit dem täglichen Übungsmodus von DataCamp täglich üben kannst! Du findest sie direkt auf deinem Dashboard. Wenn du den täglichen Übungsmodus noch nicht kennst, lies hier nach! Und hier findest du den gesamten Katalog der Python-Kurse von DataCamp.

Obwohl List Comprehensions unseren Code prägnanter machen können, ist es wichtig, dass unser endgültiger Code so lesbar wie möglich ist. Daher sollten sehr lange einzelne Codezeilen vermieden werden, um sicherzustellen, dass unser Code benutzerfreundlich ist.