Verstehen von List Comprehensions in Python 3

Einführung

Listenverständnisse bieten eine prägnante Möglichkeit, Listen basierend auf bestehenden Listen zu erstellen. Bei der Verwendung von Listenverständnissen können Listen unter Nutzung beliebiger iterierbarer Objekte, einschließlich Zeichenfolgen und Tupel, erstellt werden.

Syntaktisch besteht eine List Comprehension aus einem Iterable, das einen Ausdruck enthält, gefolgt von einer for-Klausel. Darauf können zusätzliche for- oder if-Klauseln folgen, daher wird dir eine Vertrautheit mit for-Schleifen und bedingten Anweisungen helfen, List Comprehensions besser zu verstehen.

Listenkomprehensionen bieten eine alternative Syntax zum Erstellen von Listen und anderen sequentiellen Datentypen. Während andere Iterationsmethoden, wie for-Schleifen, ebenfalls verwendet werden können, um Listen zu erstellen, werden Listenkomprehensionen möglicherweise bevorzugt, da sie die Anzahl der in Ihrem Programm verwendeten Zeilen begrenzen können.

Voraussetzungen

Sie sollten Python 3 installiert und eine Programmierumgebung auf Ihrem Computer oder Server eingerichtet haben. Wenn Sie keine Programmierumgebung eingerichtet haben, können Sie auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server verweisen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Listenverständnis

In Python werden Listen-Komprehensionen wie folgt erstellt:

list_variable = [x for x in iterable]

Eine Liste oder ein anderes Iterable wird einer Variablen zugewiesen. Zusätzliche Variablen, die für Elemente innerhalb des Iterables stehen, werden um eine for-Klausel herum konstruiert. Das in-Schlüsselwort wird verwendet, wie es in for-Schleifen der Fall ist, um über das iterable zu iterieren.

Schauen wir uns ein Beispiel an, das eine Liste basierend auf einem String erstellt:

shark_letters = [letter for letter in 'shark']
print(shark_letters)

Hier wird die neue Liste der Variablen shark_letters zugewiesen, und letter wird verwendet, um für die Elemente des iterierbaren Strings 'shark' zu stehen.

Um zu bestätigen, wie die neue Liste shark_letters aussieht, rufen wir sie mit print() auf und erhalten die folgende Ausgabe:

['s', 'h', 'a', 'r', 'k']

Die Liste, die wir mit der Listenverständnis erstellt haben, besteht aus den Gegenständen im String 'shark', das heißt, ein String für jeden Buchstaben.

List-Comprehensions können als for-Schleifen umgeschrieben werden, wobei nicht jede for-Schleife in eine List-Comprehension umgeschrieben werden kann.

Mit unserer Listenverständnis, die die shark_letters Liste oben erstellt hat, lassen Sie uns dies als eine for Schleife umschreiben. Dies kann uns helfen, besser zu verstehen, wie das Listenverständnis funktioniert.

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

Beim Erstellen einer Liste mit einer for-Schleife muss die der Liste zugewiesene Variable mit einer leeren Liste initialisiert werden, wie in der ersten Zeile unseres Codeblocks. Die for-Schleife iteriert dann über das Element und verwendet die Variable letter im iterierbaren String 'shark'. Innerhalb der for-Schleife wird jedes Element des Strings mit der Methode list.append(x) zur Liste hinzugefügt.

Das Umschreiben der Listenverständnis als eine for-Schleife liefert uns dasselbe Ergebnis:

['s', 'h', 'a', 'r', 'k']

Listenverständnisse können als for-Schleifen umgeschrieben werden, und einige for-Schleifen können umgeschrieben werden, um Listenverständnisse zu sein, um den Code prägnanter zu machen.

Bedingungen mit List Comprehensions verwenden

List-Comprehensions können bedingte Anweisungen nutzen, um vorhandene Listen oder andere sequenzielle Datentypen beim Erstellen neuer Listen zu modifizieren.

Lassen Sie uns ein Beispiel für eine if-Anweisung in einer Listenkomprehension ansehen:

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

Die Listenverständnis verwendet das Tupel fish_tuple als Grundlage für die neue Liste namens fish_list. Die Schlüsselwörter for und in werden verwendet, wie im vorherigen Abschnitt, und jetzt wird eine if-Anweisung hinzugefügt. Die if-Anweisung besagt, dass nur die Elemente hinzugefügt werden, die nicht dem String 'octopus' entsprechen, sodass die neue Liste nur Elemente aus dem Tupel aufnimmt, die nicht mit 'octopus' übereinstimmen.

Wenn wir dies ausführen, werden wir feststellen, dass fish_list die gleichen Zeichenfolgen-Elemente wie fish_tuple enthält, mit der Ausnahme, dass die Zeichenfolge 'octopus' weggelassen wurde:

['blowfish', 'clownfish', 'catfish']

Unsere neue Liste enthält daher jedes Element des ursprünglichen Tupels, mit Ausnahme des Strings, der durch die Bedingung ausgeschlossen wird.

Wir werden ein weiteres Beispiel erstellen, das mathematische Operatoren, ganze Zahlen und den range() Sequenztyp verwendet.

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

Die Liste, die erstellt wird, number_list, wird mit den quadrierten Werten jedes Elements im Bereich von 0-9 gefüllt, wenn der Wert des Elements durch 2 teilbar ist. Die Ausgabe ist wie folgt:

[0, 4, 16, 36, 64]

Um etwas genauer zu erläutern, was die Listenkomprehension macht, lassen Sie uns überlegen, was ausgegeben würde, wenn wir nur x für x in range(10) aufrufen würden. Unser kleines Programm und die Ausgabe würden dann wie folgt aussehen:

number_list = [x for x in range(10)]
print(number_list)

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

Jetzt fügen wir die Bedingungsanweisung hinzu:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

[0, 2, 4, 6, 8]

Die if-Anweisung hat die Elemente in der endgültigen Liste auf nur die Artikel beschränkt, die durch 2 teilbar sind, und alle ungeraden Zahlen weggelassen.

Schließlich können wir den Operator hinzufügen, um jedes x zu quadrieren:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

Jede der Zahlen in der vorherigen Liste von [0, 2, 4, 6, 8] wird jetzt quadriert:

[0, 4, 16, 36, 64]

Sie können verschachtelte if-Aussagen auch mit einer Listenverständnis replizieren:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

Hier wird die Listenverständnis zunächst überprüfen, ob die Zahl x durch 3 teilbar ist, und dann überprüfen, ob x durch 5 teilbar ist. Wenn x beide Anforderungen erfüllt, wird es ausgedruckt, und die Ausgabe ist:

[0, 15, 30, 45, 60, 75, 90]

Bedingte if-Anweisungen können verwendet werden, um zu steuern, welche Elemente aus einer bestehenden Sequenz in die Erstellung einer neuen Liste einbezogen werden.

Verschachtelte Schleifen in einer Listenkomprehension

Verschachtelte Schleifen können verwendet werden, um mehrere Iterationen in unseren Programmen durchzuführen.

Dieses Mal werden wir eine bestehende geschachtelte for-Schleifen-Konstruktion überprüfen und uns schrittweise zu einer Listenkomprehension hinarbeiten.

Unser Code wird eine neue Liste erstellen, die über zwei Listen iteriert und mathematische Operationen basierend auf ihnen durchführt. Hier ist unser verschachtelter for-Schleifen-Codeblock:

my_list = []

for x in [20, 40, 60]:
	for y in [2, 4, 6]:
		my_list.append(x * y)

print(my_list)

Wenn wir diesen Code ausführen, erhalten wir folgende Ausgabe:

[40, 80, 120, 80, 160, 240, 120, 240, 360]

Dieser Code multipliziert die Elemente der ersten Liste mit den Elementen der zweiten Liste in jeder Iteration.

Um dies in eine Listenverständnis umzuwandeln, werden wir jede der Codezeilen in eine Zeile kondensieren, beginnend mit der x * y Operation. Dies wird gefolgt von der äußeren for Schleife, dann der inneren for Schleife. Wir werden eine print() Anweisung unter unserem Listenverständnis hinzufügen, um zu bestätigen, dass die neue Liste mit der Liste übereinstimmt, die wir mit unserem verschachtelten for Schleifenblock oben erstellt haben:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

[40, 80, 120, 80, 160, 240, 120, 240, 360]

Unsere Listenverständnis nimmt die geschachtelten for-Schleifen und fasst sie in eine Zeile Code zusammen, während genau die gleiche Liste erstellt wird, die der my_list-Variable zugewiesen werden soll.

Listenkomprehensionen bieten uns eine prägnante Möglichkeit, Listen zu erstellen, wodurch wir mehrere Codezeilen auf eine einzige Zeile reduzieren können. Es ist jedoch wichtig, daran zu denken, dass die Lesbarkeit unseres Codes immer Vorrang haben sollte. Wenn eine Listenkomprehensionszeile zu lang oder unübersichtlich wird, ist es möglicherweise am besten, sie in Schleifen aufzuteilen.

Schlussfolgerung

Listenverständnisse erlauben es uns, eine Liste oder eine andere Sequenz in eine neue Liste zu transformieren. Sie bieten eine prägnante Syntax, um diese Aufgabe zu erfüllen, und begrenzen unsere Codezeilen.

List Comprehensions folgen der mathematischen Form der Mengenerzeugungsnotation oder Mengenverständnis, daher können sie für Programmierer mit einem mathematischen Hintergrund besonders intuitiv sein.

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