Verständnis von Listenabstraktionen in Python 3

Einführung

List Comprehensions bieten eine prägnante Möglichkeit, Listen basierend auf vorhandenen Listen zu erstellen. Bei der Verwendung von List Comprehensions können Listen erstellt werden, indem beliebige iterierbare Objekte verwendet werden, einschließlich Zeichenketten und Tupel.

Syntaktisch bestehen List Comprehensions aus einem iterierbaren Objekt, das von einem Ausdruck gefolgt wird, gefolgt von einer for-Klausel. Dies kann durch zusätzliche for– oder if-Klauseln ergänzt werden, daher wird Ihnen die Vertrautheit mit for-Schleifen und bedingten Anweisungen helfen, List Comprehensions besser zu verstehen.

List comprehensions bieten eine alternative Syntax zum Erstellen von Listen und anderen sequentiellen Datentypen. Während andere Methoden der Iteration, wie z.B. for-Schleifen, ebenfalls verwendet werden können, um Listen zu erstellen, werden List Comprehensions bevorzugt, da sie die Anzahl der verwendeten Zeilen in Ihrem Programm 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 sich an die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server entsprechend Ihrem Betriebssystem (Ubuntu, CentOS, Debian usw.) wenden.

List Comprehensions

In Python werden List Comprehensions wie folgt konstruiert:

list_variable = [x for x in iterable]

A list, or other iterable, is assigned to a variable. Additional variables that stand for items within the iterable are constructed around a for clause. The in keyword is used as it is in for loops, to iterate over the iterable.

Lassen Sie uns ein Beispiel betrachten, 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 die Elemente im iterierbaren String 'shark' zu repräsentieren.

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

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

Die Liste, die wir mit der Listenabstraktion erstellt haben, besteht aus den Elementen im String 'shark', das heißt, ein String für jeden Buchstaben.

Listenabstraktionen können als for-Schleifen umgeschrieben werden, obwohl nicht jede for-Schleife als Listenabstraktion umgeschrieben werden kann.

Verwenden wir unsere Listenabstraktion, die die Liste shark_letters oben erstellt hat, und schreiben wir sie als for-Schleife um. Dies kann uns helfen, besser zu verstehen, wie die Listenabstraktion funktioniert.

shark_letters = []

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

print(shark_letters)

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

Die Umformung der Listenkomprehension als for-Schleife liefert uns dieselbe Ausgabe:

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

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

Verwendung von Bedingungen mit Listenkomprehensionen

Listenkomprehensionen können bedingte Anweisungen verwenden, um vorhandene Listen oder andere sequenzielle Datentypen zu modifizieren, wenn neue Listen erstellt werden.

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

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

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

Die List Comprehension verwendet das Tupel fish_tuple als Basis für die neue Liste namens fish_list. Die Schlüsselwörter for und in werden verwendet, wie sie im Abschnitt oben verwendet wurden, und jetzt wird eine if-Anweisung hinzugefügt. Die if-Anweisung besagt, dass nur diejenigen Elemente hinzugefügt werden sollen, die nicht gleich dem String 'octopus' sind, sodass die neue Liste nur Elemente aus dem Tupel enthält, die nicht zu 'octopus' passen.

Wenn wir dies ausführen, werden wir feststellen, dass fish_list dieselben Zeichenfolgenelemente wie fish_tuple enthält, mit Ausnahme der Tatsache, dass die Zeichenfolge 'octopus' ausgelassen wurde:

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

Unsere neue Liste enthält daher jedes Element des Originaltupels, mit Ausnahme der Zeichenfolge, die durch die bedingte Anweisung ausgeschlossen wird.

Wir erstellen ein weiteres Beispiel, das mathematische Operatoren, Ganzzahlen und den range()-Sequenztyp verwendet.

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

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

Output
[0, 4, 16, 36, 64]

Um die Liste zu zerlegen, was die Listenabfrage genau macht, überlegen wir, was ausgegeben würde, wenn wir nur x for 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)

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

Jetzt fügen wir die bedingte Anweisung hinzu:

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

Output
[0, 2, 4, 6, 8]

Die if-Anweisung hat die Elemente in der endgültigen Liste auf nur diejenigen beschränkt, die durch 2 teilbar sind, wobei alle ungeraden Zahlen ausgelassen werden.

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)

Also werden alle Zahlen in der vorherigen Liste von [0, 2, 4, 6, 8] jetzt quadriert:

Output
[0, 4, 16, 36, 64]

Sie können auch verschachtelte if-Anweisungen mit einer Listenabfrage replizieren:

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

Hier überprüft die Listenabfrage zunächst, ob die Zahl x durch 3 teilbar ist, und dann, ob x durch 5 teilbar ist. Wenn x beide Anforderungen erfüllt, wird es gedruckt, und die Ausgabe lautet:

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

Bedingte if-Anweisungen können verwendet werden, um zu steuern, welche Elemente aus einer vorhandenen Sequenz bei der Erstellung einer neuen Liste enthalten sind.

Verschachtelte Schleifen in einer Listenabfrage

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

Dieses Mal werden wir eine vorhandene verschachtelte for-Schleifenkonstruktion überprüfen und uns auf dem Weg zu einer Listenkomprehension arbeiten.

Unser Code wird eine neue Liste erstellen, die über 2 Listen iteriert und basierend darauf mathematische Operationen 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 die folgende Ausgabe:

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

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

Um dies in eine Listenkomprehension zu verwandeln, werden wir jede Zeile des Codes in eine Zeile zusammenfassen, beginnend mit der Operation x * y. Dies wird durch die äußere for-Schleife gefolgt, dann durch die innere for-Schleife. Wir fügen eine print()-Anweisung unter unserer Listenkomprehension hinzu, 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)

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

Unsere Listenkomprehension nimmt die verschachtelten for-Schleifen und flacht sie zu einer Codezeile ab, während sie immer noch genau dieselbe Liste erstellt, die der Variablen my_list zugewiesen wird.

Listenkomprehensionen bieten uns eine prägnante Möglichkeit, Listen zu erstellen, indem wir mehrere Zeilen Code in eine einzige Zeile destillieren können. Es ist jedoch wichtig im Gedächtnis zu behalten, dass die Lesbarkeit unseres Codes immer Vorrang haben sollte. Wenn eine Listenkomprehensionszeile zu lang oder unhandlich wird, ist es möglicherweise am besten, sie in Schleifen aufzubrechen.

Zusammenfassung

List Comprehensions ermöglichen es uns, eine Liste oder eine andere Sequenz in eine neue Liste zu transformieren. Sie bieten eine prägnante Syntax für die Durchführung dieser Aufgabe und begrenzen unsere Codezeilen.

List Comprehensions folgen der mathematischen Form der Mengenbildung oder Mengenabstraktion, daher können sie besonders intuitiv für Programmierer mit mathematischem Hintergrund sein.

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