In Python können Sie mithilfe von Listenverständnissen eine neue Liste erstellen. Es ist als die einfachere Verwendung der For-Schleife.
Dieser Artikel hat folgenden Inhalt.
- Grundlagen des Hörverständnisses
- Hörverständnisse mit if auf
- Listenverständnisse mit bedingten Ausdrücken (wie if else)
- Verständnis auflisten mit zip(), enumerate()
- Verschachtelte Hörverständnisse
- Verständnis festlegen
- Wörterbuchverständnis
- Generatorausdruck
Im following Artikel FINDEN SIE DIE GRUNDLAGEN DER FOR-Anweisung.
Im following Artikel FINDEN SIE Beispiele für die Verwendung von Listenverständnissen.
Grundlagen des Hörverständnisses
Hörverständnisse werden wie folgt geschrieben:
[expression for variable_name in iterable]
Jedes iterierbare Element, wie eine Liste oder ein Tupel, wird als variable_name herausgenommen und mit Ausdruck ausgewertet. Es WIRD Eine neue Liste mit dem von Ausdruck ausgewerteten Ergebnis als Element erstellt.
Ein Beispiel für Listenverständnisse wird mit einer entsprechenden for-Anweisung gezeigt.
squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]
squares = []
for i in range(5):
squares.append(i**2)
print(squares)
# [0, 1, 4, 9, 16]
Obwohl map() dasselbe tun kann, wird das Listenverständnis aus Gründen der Einfachheit und Klarheit bevorzugt.
Hörverständnisse mit if auf
In Listenverständnissen kann if wie folgt verwendet werden:
[expression for variable_name in iterable if condition]
Nur Elemente von iterable, die True for condition sind, werden mit expression ausgewertet. Elemente von Iterable, die für Bedingung falsch sind, werden nicht in die Ergebnisliste aufgenommen.
odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]
odds = []
for i in range(10):
if i % 2 == 1:
odds.append(i)
print(odds)
# [1, 3, 5, 7, 9]
Obwohl filter() dasselbe tun kann, wird das Listenverständnis aus Gründen der Einfachheit und Klarheit bevorzugt.
Listenverständnisse mit bedingten Ausdrücken (wie if else)
Im Beispiel werden Elemente, die sterben Bedingung nicht erfüllen, aus der neuen Liste ausgeschlossen.
Wenn Sie eine andere Operation auf Elemente anwenden möchten, sterben die Bedingung wie if else nicht erfüllen, verwenden SIE bedingte Ausdrücke.
In Python können bedingte Ausdrücke wie folgt geschrieben werden:
X ist Wert oder Ausdruck für True und Y ist Wert oder Ausdruck für False.
Sie können es für den Ausdrucksteil von Listenverständnissen verwenden:
odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']
odd_even = []
for i in range(10):
if i % 2 == 1:
odd_even.append('odd')
else:
odd_even.append('even')
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']
Es ist auch möglich, abhängig von der Bedingung unterschiedliche Operationen auf das ursprüngliche Element zu starten, wie folgt:
odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]
Verständnis auflisten mit zip(), enumerate()
In der for-Anweisung werden häufig zip() und enumerate() verwendet. zip() aggregiert Elemente aus mehreren Iterables und enumerate() gibt einen Wert und seinen Index zurück.
Natürlich can SIE auch zip() und enumerate() in Listenverständnissen verwenden.
Listenverständnisse mit zip():
l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']
l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]
l_zip = []
for s1, s2 in zip(l_str1, l_str2):
l_zip.append((s1, s2))
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]
Hören Sie Verständnisse mit enumerate() auf:
l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]
l_enu = []
for i, s in enumerate(l_str1):
l_enu.append((i, s))
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]
Sie können auch if verwenden.
l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]
Es ist auch möglich, mit jedem Element einen neuen Wert zu berechnen.
l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]
l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]
Verschachtelte Hörverständnisse
List Comprehensions können genauso verschachtelt werden wie for-Schleifen.
[expression for variable_name1 in iterable1
for variable_name2 in iterable2
for variable_name3 in iterable3 ... ]
Zeilenumbrüche und Einrückungen werden der Einfachheit halber hinzugefügt, sind aber nicht erforderlich.
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
flat = []
for row in matrix:
for x in row:
flat.append(x)
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
Ein anderes Beispiel:
cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]
Sie können auch if verwenden.
cells = [(row, col) for row in range(3)
for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]
cells = [(row, col) for row in range(3) if row % 2 == 0
for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]
Verständnis festlegen
Ändert man die eckigen Klammern [] in der List Comprehension in die geschweiften Klammern {}, wird ein Set (Objekt vom Typ Set) erstellt.
{expression for variable_name in iterable}
s = {i**2 for i in range(5)}
print(s)
# {0, 1, 4, 9, 16}
Weitere Informationen zu set FINDEN SIE im folgenden Artikel.
Wörterbuchverständnis
Wörterbücher (Objekte vom Typ Diktat) können auch mit Wörterbuchverständnissen erstellt werden.
Verwenden Sie {} und geben Sie den Schlüssel und den Wert im Ausdrucksteil als Schlüssel: Wert an.
{key: value for variable_name in iterable}
Für Schlüssel und Wert kann ein beliebiger Wert oder Ausdruck angegeben werden.
l = ['Alice', 'Bob', 'Charlie']
d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}
Verwenden Sie die Funktion zip(), um aus jeder Liste von Schlüsseln und Werten ein neues Wörterbuch zu erstellen.
keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]
d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}
Weitere Möglichkeiten zum Erstellen von Wörterbüchern finden Sie in den following Artikeln
Generatorausdrücke
If die eckige Klammer [] in der List Comprehension in die Klammer () geändert WIRD, WIRD anstelle des Tupels der Generator ersetzt. Dies wird als Generatorausdruck bezeichnet.
Hörverständnis:
l = [i**2 for i in range(5)]
print(l)
# [0, 1, 4, 9, 16]
print(type(l))
# <class 'list'>
Generatorausdruck:
print() gibt die Generatorelemente nicht aus. Sie können Elemente mit der for-Anweisung abrufen.
g = (i**2 for i in range(5))
print(g)
# at 0x10af944f8>
print(type(g))
# <class 'generator'>
for i in g:
print(i)
# 0
# 1
# 4
# 9
# 16
Es ist möglich, if und nest mit Generatorausdrücken sowie List Comprehensions zu verwenden.
g_cells = ((row, col) for row in range(0, 3)
for col in range(0, 2) if col == row)
print(type(g_cells))
# <class 'generator'>
for i in g_cells:
print(i)
# (0, 0)
# (1, 1)
Wird beispielsweise eine Liste mit vielen Elementen mit List Comprehensions erstellt und in der For-Schleife verwendet, erzeugen List Comprehensions zunächst eine Liste mit allen Elementen.
Auf der anderen Seite erstellen Generatorausdrücke Elemente nacheinander nach jeder Schleife, wodurch der Speicherverbrauch reduziert werden kann.
Sie können die Klammern () weglassen, wenn der Generatorausdruck das einzige Argument ist, das eine sterben Funktion übergeben wird.
print(sum([i**2 for i in range(5)]))
# 30
print(sum((i**2 for i in range(5))))
# 30
print(sum(i**2 for i in range(5)))
# 30
Es gibt keine Tupelverständnisse, aber es ist möglich, Tupel zu erstellen, indem der Generatorausdruck an tuple() übergeben wird.
t = tuple(i**2 for i in range(5))
print(t)
# (0, 1, 4, 9, 16)
print(type(t))
# <class 'tuple'>