Python indlejrede løkker
I Python-programmeringssproget er der to typer sløjfer, som er for sløjfe og mens loop . Ved at bruge disse loops kan vi oprette indlejrede loops i Python. Indlejrede løkker betyder løkker inde i en løkke. For eksempel mens loop inde i for-løkken, for loop inde i for-løkken osv.
Python indlejrede løkker
Python Nested Loops Syntaks:
Outer_loop-udtryk:
Inner_loop udtryk:
Udsagn inde i inner_loop
Statement inde i Outer_loop
Eksempler på Python Nested Loops
Eksempel 1: Grundlæggende eksempel på Python Nested Loops
Python3
x> => [> 1> ,> 2> ]> y> => [> 4> ,> 5> ]> for> i> in> x:> > for> j> in> y:> > print> (i, j)> |
Produktion:
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> |
Tidskompleksitet: På 2 )
Hjælpeplads: O(1)
Eksempel 2: Udskrivning af multiplikationstabel ved hjælp af Python indlejret for loops
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> ()> |
Produktion:
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
Tidskompleksitet: På 2 )
Hjælpeplads: O(1)
I det ovenstående eksempel tager vi en ydre for-løkke, der løber fra 2 til 3 for multiplikationstabellen med 2 og 3, og inde i den løkke tager vi en indre for-løkke, der løber fra 1 til 10 inde i, at vi udskriver multiplikation tabel ved at gange hver iterationsværdi af indre sløjfe med iteration værdien af den ydre sløjfe, som vi ser i nedenstående output.
Eksempel 3: Udskrivning med forskellige indre og ydre indlejrede løkker
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 ')> |
Produktion:
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
Tidskompleksitet: På 2 )
Hjælpeplads: O(1)
I dette eksempel initialiserer vi to lister med nogle strenge. Gem størrelsen af list2 i 'list2_Size' ved hjælp af len()-funktionen og brug den i while-løkken som en tæller. Derefter køres en ydre for løkke til gentag over liste1 og inde i den løkke køres en indre while-løkke for at iterere over liste2 ved hjælp af listeindeksering inde i, at vi udskriver hver værdi af liste2 for hver værdi af liste1.
Brug af break statement i indlejrede loops
Det er en type sløjfekontrolerklæring. I en løkke kan vi bruge pauseerklæring at forlade løkken. Når vi bruger en break-sætning i en løkke, springer den resten af iterationen over og afslutter løkken. lad os forstå det ved hjælp af et eksempel.
Kode:
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> ()> |
Produktion:
2 * 1 = 2 3 * 1 = 3 3 * 2 = 6
Tidskompleksitet: På 2 )
Hjælpeplads: O(1)
Ovenstående kode er den samme som i eksempel 2 I denne kode bruger vi en break-sætning inde i den indre løkke ved at bruge hvis erklæring . Inde i den indre løkke, hvis 'i' bliver lig med 'j', så vil den indre løkke blive afsluttet og ikke eksekveret resten af iterationen, som vi kan se i outputtabellen med 3 udskrives op til to iterationer, fordi i den næste iteration 'i' bliver lig med 'j' og løkken brydes.
Brug af fortsæt-sætning i indlejrede løkker
En fortsæt-sætning er også en type loop-kontrol-erklæring. Det er lige det modsatte af pauseerklæringen. Fortsæt-sætningen tvinger løkken til at springe til næste iteration af løkken, mens break-sætningen afslutter løkken. Lad os forstå det ved at bruge kode.
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> ()> |
Produktion:
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
Tidskompleksitet: På 2 )
Hjælpeplads: O(1)
I ovenstående kode i stedet for at bruge en break-sætning, bruger vi en continue-sætning. Her, når 'i' bliver lig med 'j' i den indre løkke, springer den resten af koden i den indre løkke over og springer på næste iteration, som vi ser i outputtet 2 * 2 = 4 og 3 * 3 = 9 er ikke udskrevet, fordi 'i' på det tidspunkt bliver lig med 'j'.
Enkeltlinje indlejrede sløjfer ved hjælp af listeforståelse
For at konvertere de multiline indlejrede løkker til en enkelt linje, skal vi bruge listeforståelse i Python . Listeforståelse inkluderer parenteser bestående af udtryk, som udføres for hvert element, og for-løkken for at iterere over hvert element i listen.
Syntaks for listeforståelse:
ny liste = [ udtryk(element) til element i gammel liste hvis tilstand ]
Kode:
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)> |
Produktion:
[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
I ovenstående kode gemmer vi en liste inde i listen ved hjælp af listeforståelse i den indre sløjfe af listeforståelse [j for j i område(3)] for at lave en liste [0, 1, 2] for hver iteration af den ydre loop for i i området(5).
Tidskompleksitet: På 2 ) Det er hurtigere end indlejrede løkker
Hjælpeplads: På)
