In de programmeertaal Python zijn er twee soorten lussen for loop En herhalingslus . Met behulp van deze lussen kunnen we geneste lussen in Python maken. Met geneste lussen worden lussen binnen een lus bedoeld. Bijvoorbeeld: while-lus binnen de for-lus, for-lus binnen de for-lus, enz.
array elementen toevoegen java
Python geneste lussen
Syntaxis van geneste lussen in Python:
Outer_loop-expressie:
Inner_loop-expressie:
Verklaring binnen inner_loop
Verklaring binnen Outer_loop
Voorbeelden van geneste lussen van Python
Voorbeeld 1: basisvoorbeeld van geneste Python-lussen
Python3
x>=> [>1>,>2>]> y>=> [>4>,>5>]> for> i>in> x:> >for> j>in> y:> >print>(i, j)> |
>
>
Uitgang:
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> |
>
>
Tijdcomplexiteit: Op2)
Hulpruimte: O(1)
Voorbeeld 2: Tabel van vermenigvuldiging afdrukken met Python genest voor lussen
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>()> |
>
>
Uitgang:
probeer catchblock eens in java
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>
Tijdcomplexiteit: Op2)
Hulpruimte: O(1)
In het bovenstaande voorbeeld nemen we een buitenste for-lus die loopt van 2 naar 3 voor de vermenigvuldigingstabel van 2 en 3 en dan nemen we binnen die lus een binnenste for-lus die loopt van 1 naar 10, waarin we de vermenigvuldiging afdrukken tabel door elke iteratiewaarde van de binnenlus te vermenigvuldigen met de iteratie waarde van de buitenste lus zoals we zien in de onderstaande uitvoer.
Voorbeeld 3: Afdrukken met verschillende geneste binnen- en buitenlussen
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-wiskunde willekeurig
Uitgang:
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>
Tijdcomplexiteit: Op2)
Hulpruimte: O(1)
In dit voorbeeld initialiseren we twee lijsten met enkele strings. Sla de grootte van lijst2 op in ‘list2_Size’ met behulp van de len()-functie en gebruik deze in de while-lus als teller. Voer daarna een buitenste for-lus uit herhaal lijst1 en binnen die lus voer je een innerlijke while-lus uit om lijst2 te herhalen met behulp van lijstindexering, waarin we elke waarde van lijst2 afdrukken voor elke waarde van lijst1.
Break-instructie gebruiken in geneste lussen
Het is een soort luscontrole-instructie. In een lus kunnen we de verklaring breken om de lus te verlaten. Wanneer we een break-instructie in een lus gebruiken, wordt de rest van de iteratie overgeslagen en wordt de lus beëindigd. laten we het begrijpen aan de hand van een voorbeeld.
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>()> |
>
>
Uitgang:
2 * 1 = 2 3 * 1 = 3 3 * 2 = 6>
Tijdcomplexiteit: Op2)
Hulpruimte: O(1)
De bovenstaande code is hetzelfde als in voorbeeld 2. In deze code gebruiken we een break-instructie in de binnenste lus door gebruik te maken van de als verklaring . Als 'i' binnen de binnenste lus gelijk wordt aan 'j', wordt de binnenste lus beëindigd en niet uitgevoerd. De rest van de iteratie, zoals we kunnen zien in de uitvoertabel van 3, wordt afgedrukt tot twee iteraties, omdat in de volgende iteratie 'i' wordt gelijk aan 'j' en de lus breekt.
Gebruik de continue-instructie in geneste lussen
Een continue-instructie is ook een soort luscontrole-instructie. Het is precies het tegenovergestelde van de break-instructie. De continue-instructie dwingt de lus om naar de volgende iteratie van de lus te springen, terwijl de break-instructie de lus beëindigt. Laten we het begrijpen door code te gebruiken.
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>()> |
>
>
Uitgang:
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>
Tijdcomplexiteit: Op2)
Hulpruimte: O(1)
In de bovenstaande code gebruiken we in plaats van een break-instructie een continue-instructie. Wanneer 'i' hier gelijk wordt aan 'j' in de binnenste lus, slaat het de rest van de code in de binnenste lus over en springt naar de volgende iteratie, zoals we zien in de uitvoer 2 * 2 = 4 en 3 * 3 = 9 is niet afgedrukt omdat 'i' op dat moment gelijk wordt aan 'j'.
Enkele lijn Geneste lussen met behulp van lijstbegrip
Om de geneste lussen met meerdere regels om te zetten in een enkele regel gaan we gebruiken lijstbegrip in Python . Lijstbegrip omvat haakjes bestaande uit een expressie, die voor elk element wordt uitgevoerd, en de for-lus om over elk element in de lijst te itereren.
Syntaxis van lijstbegrip:
nieuwe lijst = [ expressie(element) voor element in oudeLijst als voorwaarde ]
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)> |
>
>
converteer char naar string
Uitgang:
[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]>
In de bovenstaande code slaan we een lijst op binnen de lijst met behulp van lijstbegrip in de binnenste lus van lijstbegrip [j for j in range(3)] om een lijst [0, 1, 2] te maken voor elke iteratie van de buitenste lus lus voor i binnen bereik(5).
Tijdcomplexiteit: Op2) Het is sneller dan geneste lussen
Hulpruimte: Op)