Listenverständnis in Python

List Comprehensions Python



Listenverständnisse werden in Python häufig verwendet, um einzeilige Anweisungen zu schreiben, die eine neue Liste oder ein neues Wörterbuch erstellen, indem sie ein iterierbares Objekt durchlaufen. In diesem Artikel wird die Verwendung von Listenverständnissen in Python erläutert, beginnend mit einer grundlegenden Erklärung der Funktionsweise von for-Schleifen in Python.

For-Schleife in Python

Eine for-Schleifenanweisung in Python iteriert sequentiell über Member von Objekten, Listen, Strings usw. Im Vergleich zu anderen Programmiersprachen ist ihre Syntax viel sauberer und erfordert keine manuelle Definition von Iterationsschritten und das Starten der Iteration. Es gibt jedoch Möglichkeiten, sein Verhalten dem anderer Programmiersprachen anzugleichen (wird in diesem Artikel nicht behandelt). Sie können auch eine gewisse Kontrolle über for-Schleifen ausüben, indem Sie Anweisungen wie continue, break, pass usw. verwenden. Unten ist ein einfaches Beispiel für eine for-Schleife in Python:







zumxin Bereich(10):
drucken(x)

Die obige for-Schleife gibt zehn Zahlen aus, die bei 0 beginnen und bei 9 enden.



Listenverständnis

Listenverständnis ist nichts anderes als eine kurze / prägnante Möglichkeit, mehrzeilige for-Schleifen in einer einzeiligen Anweisung zu schreiben. Das folgende Beispiel zum Listenverständnis erstellt eine neue Liste als [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], indem alle Werte von x darin eingeschlossen werden.



Zahlen= [xzumxin Bereich(10)]
drucken (Zahlen)

Beachten Sie, dass das Listenverständnis immer eine neue Liste erstellt und die im Ausdruck verwendeten ursprünglichen Iterables nicht ändert. Ein typischer Listenverständnisausdruck muss eine for-Klausel haben und kann von if- und else-Bedingungsanweisungen gefolgt werden. Ohne ein Listenverständnis zu verwenden, wird das obige Beispiel wie folgt geschrieben:





Zahlen= []
zumxin Bereich(10):
Zahlen.anhängen(x)

drucken (Zahlen)

Leistung und Lesbarkeit

Listenverständnisse sind schneller als for-Schleifen. Wenn Sie jedoch nicht über Hunderttausende von Elementen iterieren, werden Sie keine größeren Leistungsverbesserungen bemerken. Während das Listenverständnis eine prägnante Möglichkeit bietet, for-Schleifen zu schreiben, können komplexe Ausdrücke zu schlechter Lesbarkeit des Codes und erhöhter Ausführlichkeit führen. Es ist wichtig, den Code lesbar zu halten, es sei denn, die maximale Leistung ist für Ihr Programm unbedingt erforderlich.

Beispiel: Verwendung von Listenverständnissyntax mit Wörterbüchern und Sets

Ein Python-Wörterbuch ist eine Sammlung von Elementen, die in Schlüssel-Wert-Paaren definiert sind, während eine Menge eine Sammlung eindeutiger Werte ist, bei denen Duplikate nicht zulässig sind. Listenverständnisse können auch mit Python-Wörterbüchern und -Sets verwendet werden. Die Syntax unterscheidet sich geringfügig, anstatt den Ausdruck in eckige Klammern einzuschließen, müssen Sie jetzt geschweifte Klammern verwenden. Außerdem erhalten Sie statt einer neuen Liste ein neues Dictionary / Set-Objekt.



Daten= {'Stadt':'New York', 'Name':'John Doe'}

formatierte_daten= {k: V.Titel() zumzu,vinDaten.Produkte()}

drucken (formatierte_daten)

Das obige Beispiel wandelt Zeichenfolgenwerte in die Groß-/Kleinschreibung um und erstellt ein neues Wörterbuch namens formatted_data, dessen Ausgabe lautet: {‘city’: ‘New York’, ‘name’: ‘John ​​Doe’}. Sie können das Wörterbuch auch ändern / direkt einstellen, indem Sie die vorhandene Wörterbuchvariable auf der linken Seite angeben.

Daten= {'Stadt':'New York', 'Name':'John Doe'}

Daten= {k: V.Titel() zumzu,vinDaten.Produkte()}

drucken (Daten)

Ohne Wörterbuchverständnis würde der Code so aussehen:

Daten= {'Stadt':'New York', 'Name':'John Doe'}

formatierte_daten= {}

zumzu,vinDaten.Produkte():
formatierte_daten[zu] =V.Titel()

drucken (formatierte_daten)

Da es in Sets keine Schlüssel-Wert-Paare gibt, kann ein Set-Verständnis genauso wie ein Listen-Verständnis definiert werden. Der einzige Unterschied besteht in der Verwendung von geschweiften Klammern.

Beispiel: Mehrere For-Schleifen in einem Listenverständnis

Das oben erwähnte Beispiel zum Listenverständnis ist einfach und verwendet eine einzelne for-Anweisung. Unten ist ein Beispiel, das mehrere for-Schleifen und eine bedingte if-Anweisung verwendet.

Adjektive= ['Scheibe', 'Eoan', 'Fokus', 'Kunstvoll']

Tiere= ['Dingo', 'Hermelin', 'Die Grube', 'Biber']

Codenamen= [x +''+ undzumxinAdjektivezumundinTierewennund.beginnt mit(x[0])]

drucken (Codenamen)

Der Code zeigt [‘Disco Dingo’, ‘Eoan Hermine’, ‘Focal Fossa’] als Ausgabe an. Die beiden for-Schleifen gehen über Adjektiv- und Tierlisten und ihre Mitglieder werden nur dann mit einem Leerzeichen verbunden, wenn der Anfangsbuchstabe beider Wörter gleich ist. Ohne Listenverständnis würde der Code so aussehen:

Adjektive= ['Scheibe', 'Eoan', 'Fokus', 'Kunstvoll']
Tiere= ['Dingo', 'Hermelin', 'Die Grube', 'Biber']

Codenamen= []

zumxinAdjektive:
zumundinTiere:
wennund.beginnt mit(x[0]):
Codenamen.anhängen(x +''+ und)

drucken (Codenamen)

Beispiel: Listenverständnis mit if-else-Klausel

Das folgende Beispiel zeigt die Verwendung von if- und else-Anweisungen im Listenverständnis.

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

Ergebnis= [Wahr wenn (x + y)%2 == 0 anders Falsch zumxinnumber_listzumundinandere_liste]

drucken (Ergebnis)

Beim Durchlaufen zweier Listen prüft das obige Listenverständnis, ob die Summe der Elementepaare gerade ist oder nicht. Wenn Sie den obigen Code ausführen, wird [True, False, True, False, False, True, False, True, True, False, True, False, False, True, False, True] als Ausgabe angezeigt. Ohne Listenverständnis würde der Code so aussehen:

number_list= [1, 2, 3, 4]
andere_liste= [5, 6, 7, 8]
Ergebnis= []

zumxinNummernliste:
zumundinandere_liste:
wenn (x + y)%2 == 0:
Ergebnis.anhängen(Wahr)
anders:
Ergebnis.anhängen(Falsch)

drucken (Ergebnis)

Abschluss

Listenverständnis bietet eine gute Möglichkeit, saubere und prägnante Schleifenanweisungen zu schreiben. Sie können jedoch schnell komplex und schwer verständlich werden, wenn mehrere Schleifen und bedingte Anweisungen verwendet werden. Am Ende kommt es auf den Komfort eines Programmierers an, aber im Allgemeinen ist es eine gute Idee, expliziten, lesbaren und leicht zu debuggenden Code zu schreiben, anstatt übermäßig Abkürzungen zu verwenden.