Dans le langage de programmation Python, il existe deux types de boucles : pour la boucle et boucle while . En utilisant ces boucles, nous pouvons créer des boucles imbriquées en Python. Les boucles imbriquées signifient des boucles à l’intérieur d’une boucle. Par exemple, une boucle while à l'intérieur de la boucle for, une boucle for à l'intérieur de la boucle for, etc.
flotter en chaîne
Boucles imbriquées Python
Syntaxe des boucles imbriquées Python :
Expression de boucle_extérieure :
Expression de boucle intérieure :
Déclaration à l'intérieur de inner_loop
Déclaration à l'intérieur de Outer_loop
Exemples de boucles imbriquées Python
Exemple 1 : exemple de base de boucles imbriquées Python
Python3
x>=> [>1>,>2>]> y>=> [>4>,>5>]> for> i>in> x:> >for> j>in> y:> >print>(i, j)> |
>
>
Sortir:
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> |
>
>
Complexité temporelle : Sur2)
Espace auxiliaire : O(1)
Exemple 2 : Impression d'une table de multiplication à l'aide de boucles for imbriquées Python
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>()> |
>
>
Sortir:
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>
Complexité temporelle : Sur2)
Espace auxiliaire : O(1)
Dans l'exemple ci-dessus, nous prenons une boucle for externe allant de 2 à 3 pour une table de multiplication de 2 et 3, puis à l'intérieur de cette boucle, nous prenons une boucle for interne qui s'étendra de 1 à 10 à l'intérieur de laquelle nous imprimons la multiplication. tableau en multipliant chaque valeur d'itération de la boucle interne par le itération valeur de la boucle externe comme nous le voyons dans la sortie ci-dessous.
Exemple 3 : Impression à l'aide de différentes boucles imbriquées intérieures et extérieures
Python3
triptyque hiver
# 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 math.random
Sortir:
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>
Complexité temporelle : Sur2)
Espace auxiliaire : O(1)
Dans cet exemple, nous initialisons deux listes avec des chaînes. Stockez la taille de list2 dans 'list2_Size' en utilisant la fonction len() et en l'utilisant dans la boucle while comme compteur. Après cela, exécutez une boucle for externe pour parcourir la liste1 et à l'intérieur de cette boucle, exécutez une boucle while interne pour parcourir list2 en utilisant l'indexation de liste à l'intérieur de laquelle nous imprimons chaque valeur de list2 pour chaque valeur de list1.
Utilisation de l'instruction break dans des boucles imbriquées
C'est un type d'instruction de contrôle de boucle. Dans une boucle, on peut utiliser le instruction de pause pour sortir de la boucle. Lorsque nous utilisons une instruction break dans une boucle, elle ignore le reste de l'itération et termine la boucle. comprenons-le à l’aide d’un exemple.
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>()> |
>
>
Sortir:
2 * 1 = 2 3 * 1 = 3 3 * 2 = 6>
Complexité temporelle : Sur2)
Espace auxiliaire : O(1)
Le code ci-dessus est le même que dans l'exemple 2. Dans ce code, nous utilisons une instruction break à l'intérieur de la boucle interne en utilisant le si déclaration . À l'intérieur de la boucle interne, si « i » devient égal à « j », alors la boucle interne sera terminée et ne sera pas exécutée. Le reste de l'itération, comme nous pouvons le voir dans le tableau de sortie de 3, est imprimé jusqu'à deux itérations car dans l'itération suivante « i » devient égal à « j » et la boucle est interrompue.
Utilisation de l'instruction continue dans des boucles imbriquées
Une instruction continue est également un type d’instruction de contrôle de boucle. C'est juste le contraire de l'instruction break. L'instruction continue force la boucle à passer à l'itération suivante de la boucle tandis que l'instruction break termine la boucle. Comprenons-le en utilisant le 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:> >continue> ># Printing inside the inner loop> >print>(i,>'*'>, j,>'='>, i>*>j)> ># Printing inside the outer loop> >print>()> |
>
>
Sortir:
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>
Complexité temporelle : Sur2)
Espace auxiliaire : O(1)
Dans le code ci-dessus, au lieu d'utiliser une instruction break, nous utilisons une instruction continue. Ici, lorsque 'i' devient égal à 'j' dans la boucle interne, il ignore le reste du code dans la boucle interne et passe à l'itération suivante comme nous le voyons dans la sortie 2 * 2 = 4 et 3 * 3 = 9 est non imprimé car à ce stade, « i » devient égal à « j ».
Boucles imbriquées sur une seule ligne utilisant la compréhension de liste
Pour convertir les boucles imbriquées multilignes en une seule ligne, nous allons utiliser compréhension de liste en Python . La compréhension de la liste comprend des parenthèses constituées d'une expression, qui est exécutée pour chaque élément, et de la boucle for pour parcourir chaque élément de la liste.
Syntaxe de compréhension de liste :
Nouvelle liste = [ expression(élément) pour élément dans ancienneListe si condition ]
Code:
boîte de liste Java
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)> |
>
>
Sortir:
[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Dans le code ci-dessus, nous stockons une liste à l'intérieur de la liste en utilisant la compréhension de liste dans la boucle interne de compréhension de liste [j pour j dans range(3)] pour créer une liste [0, 1, 2] pour chaque itération de la liste externe. boucle pour i dans la plage (5).
Complexité temporelle : Sur2) C'est plus rapide que les boucles imbriquées
Espace auxiliaire : Sur)