Ein Python-Listenverständnis besteht aus Klammern, die den Ausdruck enthalten, der für jedes Element zusammen mit der for-Schleife ausgeführt wird, um jedes Element in der Python-Liste zu durchlaufen.
Beispiel:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Ausgabe
[24, 26, 28]>
Python-Listenverständnissyntax
Syntax: neue Liste = [ Ausdruck(Element) für Element In alteListe Wenn Zustand ]
Parameter:
Ausdruck: Stellt die Operation dar, die Sie für jedes Element innerhalb der Iterable ausführen möchten. Element: Der Begriff Variable bezieht sich auf jeden Wert, der aus dem Iterable entnommen wird. iterierbar: Geben Sie die Reihenfolge der Elemente an, die Sie durchlaufen möchten (z. B. eine Liste, ein Tupel oder eine Zeichenfolge). Bedingung: (Optional) Ein Filter hilft bei der Entscheidung, ob ein Element zur neuen Liste hinzugefügt werden soll oder nicht.
Zurückkehren: Der Rückgabewert eines Listenverständnisses ist eine neue Liste, die die geänderten Elemente enthält, die die angegebenen Kriterien erfüllen.
Das Python-Listenverständnis bietet eine viel kürzere Syntax zum Erstellen einer neuen Liste basierend auf den Werten einer vorhandenen Liste.
Beispiel für Listenverständnis in Python
Hier ist ein Beispiel für die Verwendung des Listenverständnisses zum Ermitteln des Quadrats einer Zahl in Python.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Ausgabe
[1, 4, 9, 16, 25]>
Iteration mit Listenverständnis
In diesem Beispiel weisen wir der Liste 1, 2 und 3 zu und drucken die Liste mithilfe des Listenverständnisses.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Ausgabe
[1, 2, 3]>
Sogar Listen mithilfe des Listenverständnisses
In diesem Beispiel drucken wir die geraden Zahlen von 0 bis 10 mithilfe des Listenverständnisses.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Ausgabe
[0, 2, 4, 6, 8, 10]>
Matrix mit Listenverständnis
In diesem Beispiel weisen wir ganze Zahlen von 0 bis 2 bis 3 Zeilen der Matrix zu und drucken sie mit List Comprehension aus.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Ausgabe
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Listenverständnis vs. For-Schleife
Es gibt verschiedene Möglichkeiten, eine Liste zu durchlaufen. Der gebräuchlichste Ansatz ist jedoch die Verwendung von für Schleife . Schauen wir uns das folgende Beispiel an:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Ausgabe
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Oben ist die Implementierung des traditionellen Ansatzes zum Durchlaufen einer Liste, eines Strings, eines Tupels usw. dargestellt. Jetzt erledigt das Listenverständnis in Python die gleiche Aufgabe und macht das Programm außerdem einfacher.
Listenverständnisse übersetzen den traditionellen Iterationsansatz mithilfe von for-Schleife in eine einfache Formel umwandeln und so die Anwendung vereinfachen. Nachfolgend finden Sie den Ansatz zum Durchlaufen einer Liste, eines Strings, eines Tupels usw. mithilfe des Listenverständnisses in Python.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Ausgabe
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Zeitanalyse in Listenverständnissen und Schleifen
Die Listenverständnisse in Python sind sowohl rechnerisch als auch hinsichtlich des Codierungsraums und der Codierungszeit effizienter als eine for-Schleife. Normalerweise werden sie in einer einzigen Codezeile geschrieben. Das folgende Programm zeigt den Unterschied zwischen Schleifen und Listenverständnis basierend auf der Leistung.
Python
Array-Sortierung Java
# Import required module> import> time> > > # define function to implement for loop> def> for_loop(n):> >result>=> []> >for> i>in> range>(n):> >result.append(i>*>*>2>)> >return> result> > > # define function to implement list comprehension> def> list_comprehension(n):> >return> [i>*>*>2> for> i>in> range>(n)]> > > # Driver Code> > # Calculate time taken by for_loop()> begin>=> time.time()> for_loop(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for_loop:'>,>round>(end>->begin,>2>))> > # Calculate time takens by list_comprehension()> begin>=> time.time()> list_comprehension(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for list_comprehension:'>,>round>(end>->begin,>2>))> |
>
>
Ausgabe
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Aus dem obigen Programm können wir ersehen, dass das Listenverständnis deutlich schneller ist als die for-Schleife.
Verschachtelte Listenverständnisse
Verschachtelte Listenverständnisse sind nichts anderes als ein Listenverständnis innerhalb eines anderen Listenverständnisses, das verschachtelten for-Schleifen ziemlich ähnlich ist. Unten ist das Programm, das eine verschachtelte Schleife implementiert:
Python
matrix>=> []> > for> i>in> range>(>3>):> > ># Append an empty sublist inside the list> >matrix.append([])> > >for> j>in> range>(>5>):> >matrix[i].append(j)> > print>(matrix)> |
>
Java-Rückgabebefehl
>
Ausgabe
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Durch die Verwendung verschachtelter Listenverständnisse kann nun dieselbe Ausgabe in weniger Codezeilen generiert werden.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Ausgabe
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Listenverständnis und Lambda
Lambda-Ausdrücke sind nichts anderes als Kurzdarstellungen von Python-Funktionen. Durch die Verwendung von Listenverständnissen mit Lambda entsteht eine effiziente Kombination. Schauen wir uns die folgenden Beispiele an:
In diesem Beispiel fügen wir Zahlen von 10 bis 50 in die Liste ein und drucken sie aus.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Ausgabe
[10, 20, 30, 40, 50]>
Hier haben wir eine for-Schleife verwendet, um eine 10er-Tabelle zu drucken.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Ausgabe
[10, 20, 30, 40, 50]>
Hier haben wir nur das Listenverständnis verwendet, um eine Tabelle mit 10 anzuzeigen.
Python
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Ausgabe
[10, 20, 30, 40, 50]>
Schließlich verwenden wir Lambda + Listenverständnis, um die 10er-Tabelle anzuzeigen. Diese Kombination ist sehr nützlich, um für komplexe Probleme effiziente Lösungen in weniger Codezeilen zu erhalten.
Bedingungen im Listenverständnis
Wir können dem Listenverständnis auch bedingte Anweisungen hinzufügen. Wir können eine Liste erstellen mit Reichweite(), Betreiber usw. und cal wenden auch einige Bedingungen auf die Liste an, indem sie die verwenden if-Anweisung .
Wichtige Punkte
- Das Verstehen der Liste ist ein wirksames Mittel zur Beschreibung und Erstellung von Listen auf der Grundlage aktueller Listen.
- Im Allgemeinen ist das Listenverständnis leichtgewichtiger und einfacher als Standardfunktionen und -schleifen zur Listenbildung.
- Wir sollten keine langen Codes für das Listenverständnis schreiben, um einen benutzerfreundlichen Code zu gewährleisten.
- Jedes Verständnis der Liste kann in einer for-Schleife umgeschrieben werden, aber im Kontext der Listeninterpretation kann nicht jede for-Schleife umgeschrieben werden.
Nachfolgend finden Sie einige Beispiele, die die Verwendung von Listenverständnissen anstelle des traditionellen Ansatzes zum Durchlaufen von Iterable veranschaulichen:
Python-Listenverständnis mit If-else.
Im Beispiel prüfen wir, ob die Zahl von 0 bis 7 gerade ist und fügen dann ein Gerade Zahl zur Liste sonst einfügen Ungerade Zahl zur Liste.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Ausgabe
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Verschachteltes IF mit Listenverständnis
In diesem Beispiel fügen wir Zahlen in die Liste ein, die ein Vielfaches von 10 bis 100 sind, und drucken sie aus.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Ausgabe
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Zeigen Sie ein Quadrat mit Zahlen von 1 bis 10 an
In diesem Beispiel fügen wir ein Quadrat von 1 bis 10 in die Liste ein und drucken die Liste aus.
Python
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Ausgabe
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Transponierte 2D-Matrix anzeigen
In diesem Beispiel führen wir eine Transponierung der Matrix mithilfe des Listenverständnisses durch.
Python
# Assign matrix> twoDMatrix>=> [[>10>,>20>,>30>],> >[>40>,>50>,>60>],> >[>70>,>80>,>90>]]> > # Generate transpose> trans>=> [[i[j]>for> i>in> twoDMatrix]>for> j>in> range>(>len>(twoDMatrix[>0>]))]> > print>(trans)> |
>
>
Ausgabe
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Schalten Sie die Groß-/Kleinschreibung jedes Zeichens in einem String um
In diesem Beispiel schalten wir die Groß-/Kleinschreibung jedes Zeichens in einer bestimmten Zeichenfolge mithilfe des XOR-Operators mit 32 um und speichern das Ergebnis in einer Liste.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Ausgabe
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Kehren Sie jede Zeichenfolge in einem Tupel um
In diesem Beispiel kehren wir Zeichenfolgen in einer for-Schleife um, fügen sie in die Liste ein und drucken die Liste aus.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Ausgabe
['skeeG', 'rof', 'skeeG']>
Erstellen einer Liste von Tupeln aus zwei separaten Listen
In diesem Beispiel haben wir zwei Listen erstellt Namen und Alter. Wir benutzen Reißverschluss() im Listenverständnis und wir fügen den Namen und das Alter als Tupel zur Liste ein. Zum Schluss drucken wir die Liste der Tupel.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Ausgabe:
[('G', 25), ('G', 30), ('g', 35)]> Zeigt die Summe der Ziffern aller ungeraden Elemente in einer Liste an.
In diesem Beispiel haben wir eine Liste erstellt und ermitteln die Ziffernsumme jedes ungeraden Elements in der Liste.
Python
# Explicit function> def> digitSum(n):> >dsum>=> 0> >for> ele>in> str>(n):> >dsum>+>=> int>(ele)> >return> dsum> > > # Initializing list> List> => [>367>,>111>,>562>,>945>,>6726>,>873>]> > # Using the function on odd elements of the list> newList>=> [digitSum(i)>for> i>in> List> if> i &>1>]> > # Displaying new list> print>(newList)> |
>
>
Ausgabe
[16, 3, 18, 18]>
Vorteile des Listenverständnisses
- Zeiteffizienter und platzsparender als Schleifen.
- Erfordern weniger Codezeilen.
- Wandelt eine iterative Anweisung in eine Formel um.
Fragen zur Python-Listenverständnisübung
Nachfolgend finden Sie zwei Übungsfragen zum Verständnis von Python-Listen. Wir haben den grundlegenden Listenverständniscode zum Ermitteln des Zahlenwürfels und den Code zum Ermitteln der Länge eines Wortes mithilfe des Listenverständnisses und der Funktion len() behandelt.
Q1. Übungsfrage zum Zahlenwürfel unter Verwendung des Listenverständnisses
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Ausgabe
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Finden Sie eine Übungsfrage zur Wortlänge mithilfe des Listenverständnisses
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
Iterieren einer Karte in Java
>
Ausgabe
[5, 6, 6, 6]>