In der Programmiersprache Python gibt es zwei Arten von Schleifen for-Schleife Und while-Schleife . Mit diesen Schleifen können wir verschachtelte Schleifen in Python erstellen. Unter verschachtelten Schleifen versteht man Schleifen innerhalb einer Schleife. Zum Beispiel while-Schleife innerhalb der for-Schleife, for-Schleife innerhalb der for-Schleife usw.
welche Sammlung in Java
Verschachtelte Python-Schleifen
Syntax für verschachtelte Python-Schleifen:
Outer_loop-Ausdruck:
Inner_loop-Ausdruck:
Anweisung innerhalb inner_loop
Anweisung innerhalb von Outer_loop
Beispiele für verschachtelte Python-Schleifen
Beispiel 1: Grundlegendes Beispiel für verschachtelte Python-Schleifen
Python3
x>=> [>1>,>2>]> y>=> [>4>,>5>]> for> i>in> x:> >for> j>in> y:> >print>(i, j)> |
>
>
Ausgabe:
1 4 1 5 2 4 2 5>
Python3
x>=> [>1>,>2>]> y>=> [>4>,>5>]> i>=> 0> while> i <>len>(x) :> >j>=> 0> >while> j <>len>(y) :> >print>(x[i] , y[j])> >j>=> j>+> 1> >i>=> i>+> 1> |
>
>
Differenz abschneiden und löschen
Zeitkomplexität: An2)
Hilfsraum: O(1)
Beispiel 2: Drucken der Multiplikationstabelle mit verschachtelten Python-For-Schleifen
Python3
# Running outer loop from 2 to 3> for> i>in> range>(>2>,>4>):> ># Printing inside the outer loop> ># Running inner loop from 1 to 10> >for> j>in> range>(>1>,>11>):> ># Printing inside the inner loop> >print>(i,>'*'>, j,>'='>, i>*>j)> ># Printing inside the outer loop> >print>()> |
>
>
Ausgabe:
2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18 2 * 10 = 20 3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27 3 * 10 = 30>
Zeitkomplexität: An2)
Hilfsraum: O(1)
Im obigen Beispiel nehmen wir eine äußere for-Schleife, die von 2 bis 3 für die Multiplikationstabelle von 2 und 3 läuft, und dann nehmen wir innerhalb dieser Schleife eine innere for-Schleife, die von 1 bis 10 läuft, in der wir die Multiplikation drucken Tabelle durch Multiplizieren jedes Iterationswerts der inneren Schleife mit dem Wiederholung Wert der äußeren Schleife, wie wir in der folgenden Ausgabe sehen.
Beispiel 3: Drucken mit unterschiedlichen inneren und äußeren verschachtelten Schleifen
Python3
# Initialize list1 and list2> # with some strings> list1>=> [>'I am '>,>'You are '>]> list2>=> [>'healthy'>,>'fine'>,>'geek'>]> # Store length of list2 in list2_size> list2_size>=> len>(list2)> # Running outer for loop to> # iterate through a list1.> for> item>in> list1:> > ># Printing outside inner loop> >print>(>'start outer for loop '>)> ># Initialize counter i with 0> >i>=> 0> ># Running inner While loop to> ># iterate through a list2.> >while>(i # Printing inside inner loop print(item, list2[i]) # Incrementing the value of i i = i+1 # Printing outside inner loop print('end for loop ')> |
>
>
Java-String in Ganzzahl umwandeln
Ausgabe:
start outer for loop I am healthy I am fine I am geek end for loop start outer for loop You are healthy You are fine You are geek end for loop>
Zeitkomplexität: An2)
Hilfsraum: O(1)
In diesem Beispiel initialisieren wir zwei Listen mit einigen Zeichenfolgen. Speichern Sie die Größe von list2 in „list2_Size“ mit der Funktion len() und verwenden Sie sie in der while-Schleife als Zähler. Führen Sie danach eine äußere for-Schleife aus iteriere über list1 und führen Sie innerhalb dieser Schleife eine innere While-Schleife aus, um Liste2 zu durchlaufen und dabei die Listenindizierung zu verwenden. Dabei drucken wir jeden Wert von Liste2 für jeden Wert von Liste1.
Verwendung der break-Anweisung in verschachtelten Schleifen
Es handelt sich um eine Art Schleifenkontrollanweisung. In einer Schleife können wir die verwenden break-Anweisung um die Schleife zu verlassen. Wenn wir eine break-Anweisung in einer Schleife verwenden, überspringt sie den Rest der Iteration und beendet die Schleife. Lassen Sie es uns anhand eines Beispiels verstehen.
Code:
Python3
# Running outer loop from 2 to 3> for> i>in> range>(>2>,>4>):> ># Printing inside the outer loop> ># Running inner loop from 1 to 10> >for> j>in> range>(>1>,>11>):> >if> i>=>=>j:> >break> ># Printing inside the inner loop> >print>(i,>'*'>, j,>'='>, i>*>j)> ># Printing inside the outer loop> >print>()> |
>
>
Ausgabe:
2 * 1 = 2 3 * 1 = 3 3 * 2 = 6>
Zeitkomplexität: An2)
Hilfsraum: O(1)
Der obige Code ist derselbe wie in Beispiel 2. In diesem Code verwenden wir eine break-Anweisung innerhalb der inneren Schleife, indem wir die verwenden if-Anweisung . Wenn innerhalb der inneren Schleife „i“ gleich „j“ wird, wird die innere Schleife beendet und der Rest der Iteration nicht ausgeführt. Wie wir in der Ausgabetabelle von 3 sehen können, werden bis zu zwei Iterationen gedruckt, da in der nächsten Iteration 'i' wird gleich 'j' und die Schleife wird unterbrochen.
Verwendung der continue-Anweisung in verschachtelten Schleifen
Eine continue-Anweisung ist ebenfalls eine Art Schleifenkontrollanweisung. Es ist genau das Gegenteil der break-Anweisung. Die continue-Anweisung zwingt die Schleife, zur nächsten Iteration der Schleife zu springen, während die break-Anweisung die Schleife beendet. Lassen Sie es uns mithilfe von Code verstehen.
Python3
# Running outer loop from 2 to 3> for> i>in> range>(>2>,>4>):> ># Printing inside the outer loop> ># Running inner loop from 1 to 10> >for> j>in> range>(>1>,>11>):> >if> i>=>=>j:> >continue> ># Printing inside the inner loop> >print>(i,>'*'>, j,>'='>, i>*>j)> ># Printing inside the outer loop> >print>()> |
>
>
Ausgabe:
2 * 1 = 2 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18 2 * 10 = 20 3 * 1 = 3 3 * 2 = 6 3 * 4 = 12 3 * 5 = 15 3 * 6 = 18 3 * 7 = 21 3 * 8 = 24 3 * 9 = 27 3 * 10 = 30>
Zeitkomplexität: An2)
Hilfsraum: O(1)
Im obigen Code verwenden wir anstelle einer break-Anweisung eine continue-Anweisung. Wenn hier „i“ in der inneren Schleife gleich „j“ wird, überspringt es den Rest des Codes in der inneren Schleife und springt zur nächsten Iteration, wie wir in der Ausgabe sehen: 2 * 2 = 4 und 3 * 3 = 9 wird nicht gedruckt, da an diesem Punkt „i“ gleich „j“ wird.
Einzeilige verschachtelte Schleifen mit Listenverständnis
Um die mehrzeiligen verschachtelten Schleifen in eine einzelne Zeile umzuwandeln, verwenden wir Listenverständnis in Python . Das Listenverständnis umfasst Klammern, die aus einem Ausdruck bestehen, der für jedes Element ausgeführt wird, und der for-Schleife, um jedes Element in der Liste zu durchlaufen.
Syntax des Listenverständnisses:
neue Liste = [ Ausdruck(Element) für Element In alteListe Wenn Zustand ]
Code:
Python3
# Using list comprehension to make> # nested loop statement in single line.> list1>=> [[j>for> j>in> range>(>3>)]> >for> i>in> range>(>5>)]> # Printing list1> print>(list1)> |
>
>
SQL-Datentypen
Ausgabe:
[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Im obigen Code speichern wir eine Liste innerhalb der Liste mithilfe des Listenverständnisses in der inneren Schleife des Listenverständnisses [j für j in range(3)], um für jede Iteration des äußeren eine Liste [0, 1, 2] zu erstellen Schleife für i in range(5).
Zeitkomplexität: An2) Es ist schneller als verschachtelte Schleifen
Hilfsraum: An)