Introduction aux boucles imbriquées Python
Bienvenue dans un autre chapitre du cours d'apprentissage Python - Nested Loops. Une excellente façon de boucler une boucle, les boucles imbriquées ont fait leurs preuves dans tous les langages de programmation. Aujourd'hui, nous allons nous concentrer spécifiquement sur Python - les types, la syntaxe et les exemples. Alors, commençons.
Boucles imbriquées
Il serait bon de se baser brièvement sur les boucles imbriquées en général, avant de poursuivre avec Python en particulier. Si une boucle existe à l'intérieur du corps d'une autre boucle, elle est appelée boucle imbriquée. Cela signifie que nous voulons exécuter le code de boucle interne plusieurs fois. La boucle externe contrôle le nombre d'itérations que la boucle interne subira. Un exemple de base d'une boucle imbriquée est:
for (i=0; i<10; i++)
(
for (j=0; j<10; j++)
(
//This code will execute 100 times.
)
//This code will execute 10 times.
)
Une chose à noter ici est que tout type de boucle peut être imbriqué dans une autre boucle. Par exemple, une boucle while peut être imbriquée dans une boucle for ou vice versa.
Boucles imbriquées Python
1) Syntaxe de la boucle imbriquée
La syntaxe de base d'une boucle imbriquée pour en Python est:
for (iterating_variable_1) in (sequence_1): #Outer Loop
for (iterating_variable_2) in (iterating_variable_1/sequence_2): #Inner Loop
(code to execute)
Exemple
for i in range(11): #line 1
for j in range(i): #line 2
print('*', end='') #line 3
print('') #line 4
Production:
Flux d'exécution
Essayons de comprendre le flux d'exécution du programme ci-dessus. Dans le programme, nous avons utilisé deux variables d'itération i et j pour imprimer un motif d'étoiles.
Le compilateur commence par la ligne 1. Il rencontre une boucle for et une fonction range. La fonction de plage en Python génère un tableau itérable de nombres entiers de 0 au nombre spécifié dans l'argument. Le numéro d'argument est exclu du tableau. Dans notre cas, il va générer un tableau (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10). Maintenant, le compilateur sait qu'il doit exécuter le prochain ensemble d'instructions 10 fois.
Quand il passe à la ligne 2, il en rencontre un autre pour la fonction de boucle et de plage. Notez que l'argument de cette fonction de plage est une valeur calculée de notre variable d'itération i. Ainsi, il génère dynamiquement un tableau en fonction de la valeur de i. Lorsque i = 0, le tableau est vide. Lorsque i = 1, le tableau est (0). Lorsque i = 2, le tableau est (0, 1) et ainsi de suite.
Ainsi, le nombre d'exécutions de la ligne 3 dépend directement de la valeur de i. Notez la partie end = '' inline 3. C'est pour empêcher Python d'imprimer un saut de ligne après chaque étoile. Nous voulons seulement un saut de ligne à la fin de chaque itération de la boucle externe. Ainsi, nous avons explicitement imprimé un saut de ligne à la ligne 4 de notre code.
Alors maintenant, examinons de près chaque itération de notre boucle imbriquée.
Itération de la boucle externe 1
I = 0, j = (), output is a blank line.
Itération de la boucle externe 2
I = 1, j = (0), output = *
Itération de la boucle externe 3
I = 2, j = (0, 1), output = **
Itération de la boucle externe 4
I = 3, j = (0, 1, 2), output = ***
.
.
.
Itération de la boucle externe 10
I = 9, j = (0, 1, 2, 3, 4, 5, 6, 7, 8), output = *********
Itération de la boucle externe 11
I = 10, j = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), output = **********
2) Boucle imbriquée while
Syntaxe
La syntaxe d'imbrication de la boucle while en Python est:
while (expression_1): #Outer loop
(code to execute) #Optional
while (expression_2): #Inner loop
(code to execute)
Contrairement à la boucle for, la boucle while n'a pas de séquence itérable précompilée. La boucle while continue d'exécuter le code jusqu'à ce que l'expression devienne vraie. Ainsi, un développeur doit toujours garder à l'esprit pour mettre à jour la variable / expression itérative, sinon la boucle entrera en mode d'exécution infini.
Exemple
i=1 #line 1
while(i<=5): #line 2
j=5 #line 3
while(j>=i): #line 4
print(j, end=' ') #line 5
j-=1 #line 6
i+=1 #line 7
print() #line 8
Production:
Flux d'exécution
La ligne 1 du code définit la variable d'itération de la boucle externe sur la valeur initiale. La ligne suivante est le début de la boucle while externe. Il a une expression i <= 5. Cette expression est évaluée pour la valeur vraie après chaque itération. L'exécution entre dans la boucle uniquement si la condition est vraie. Dès que la condition devient fausse, la boucle est terminée.
Comme la valeur initiale de I est 1, la condition de la ligne 2 est vraie. Ainsi, le compilateur passe à la ligne 3 et définit la variable d'itération j de notre boucle interne sur 5. La ligne 4 a à nouveau une boucle while avec une expression qui est évaluée à true. Ainsi, le compilateur exécute les lignes 5 et 6. Il revient ensuite à la ligne 4 et évalue la condition. Si la condition est vraie, elle entre à nouveau dans les lignes 5 et 6. Si la condition devient fausse, la boucle est terminée et les lignes suivantes à exécuter sont les lignes 7 et 8. La même chose est suivie pour la boucle externe.
Les lignes 6 et 7 sont très importantes car elles mettent à jour notre variable itérative. Sans eux, le flux du programme entrerait en mode d'exécution infini car les expressions de la boucle while donneraient toujours la vérité.
Dois-je casser, continuer ou passer
Comme avec presque tous les autres langages de programmation, Python a également le concept de pause et de continuer. Ces mots clés aident à terminer une boucle ou à sauter une itération particulière de la boucle. Python a également un autre mot-clé - pass. Jetons un coup d'oeil à ces derniers.
1) Pause
Le mot clé break indique au compilateur de sortir d'une boucle et de terminer son exécution.
Exemple
for i in range(5):
for j in range(5):
if i == j:
break
print(j, end='')
print('')
Production:
Le programme ci-dessus rompt la boucle for interne si les valeurs de I et j sont égales. Il n'exécute pas d'autres itérations de la boucle. Cela peut être mieux compris avec la déclaration continue.
2) Continuez
Le mot clé continue indique au compilateur de sauter l'itération actuelle de la boucle et de continuer avec l'itération suivante.
Exemple
for i in range(5):
for j in range(5):
if i == j:
continue
print(j, end='')
print('')
Production:
Notez que le même programme, mais avec l'instruction continue au lieu de break, ne met pas fin à l'exécution de la boucle. Il ignore uniquement l'itération en cours.
3) Passer
Le mot-clé pass est intéressant en Python. Cela signifie simplement ne rien faire. Il est utilisé lorsque le bloc de code est requis syntaxiquement, mais vous ne voulez pas exécuter de commande. Il agit simplement comme un espace réservé.
Exemple
for i in range(5):
for j in range(5):
if i == j:
#I am not sure what to do when i equals j, so for now I will pass.
pass
print(j, end='')
print('')
Production:
Conclusion
Les boucles sont stratégiquement très importantes pour apprendre à effectuer une tâche avec un minimum de lignes de code. Ceci est juste une introduction de base aux boucles. Il est recommandé de jouer plus, de faire preuve de créativité et d'explorer davantage le potentiel des boucles.
Articles recommandés
Ceci est un guide des boucles imbriquées Python. Nous discutons ici des boucles imbriquées Python avec la syntaxe, les exemples, le flux de sortie et d'exécution. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Cadres Python
- Comment installer Python
- Guide des boucles en Python
- Qu'est-ce que l'interface Java?
- Différents types de boucles avec ses avantages
- Boucles dans VBScript avec des exemples