Constructions en boucle en Python

Contenus de la page

Je suis un développeur de logiciels avec un grand intérêt pour l’analyse de données et les statistiques.

Les constructions en boucle dans n’importe quel langage de programmation sont utilisées pour exécuter une séquence d’étapes à plusieurs reprises pendant un nombre de fois donné. Python autorise deux types de boucles : la boucle for et la boucle while. Il est également possible d’ajouter une boucle dans une autre boucle et de créer une boucle imbriquée en Python.

La boucle For

Lors de l’itération sur un tuple ou une liste, nous pouvons soit utiliser des indices et écrire une boucle for traditionnelle similaire à celle trouvée en C/C++, soit écrire une boucle for-each-sequence similaire à celle de Java. Apprenons-en plus sur les boucles for.

Itération sur les blocs de construction d’une séquence

#!/usr/bin/python3
print("Printing letters of string in each line... ")
for cur in 'Hello World!':     
    print (cur)

rhymes = ['Mary','Had','A','Little','Lamb']
print("Printing words in the rhyme in each line...")
for word in rhymes:        
    print (word)

print ("...Reached the end...")

Dans la première boucle for, nous prenons la chaîne ‘HelloWorld!’ séquence et itérer dessus en utilisant la variable d’itération. En général, la syntaxe de ce type de boucle for peut être exprimée comme suit :

for iter_var in sequence:
       # steps inside for loop.

Les deux premières boucles for montrent comment les lettres d’une chaîne et les mots d’une liste représentant une phrase sont traités comme des blocs de construction individuels de la séquence.

La sortie du programme ci-dessus sera :

Imprimer des lettres de chaîne dans chaque ligne… H e l l o W o r l d ! Imprimer des mots dans la rime de chaque ligne… Marie avait un petit agneau… Atteint la fin…

Ce type de boucle for peut également être appliqué dans le cas d’un tuple ou d’un dictionnaire. Le code ci-dessous montre comment parcourir un dictionnaire en considérant les clés ou les paires clé-valeur comme les blocs de construction de la séquence.

#!/usr/bin/python3

print("Iterating over a dictionary")
studentDict = {'firstName': 'john','lastName':'Smith', 'age': 29, 'studentId':415312}

print("Iterating using a key alone in for loop")
for key in studentDict:
    print("key: ", key, ", value: ", studentDict[key])

print("Iterating using key and value")
for foo,bar in studentDict.items():
    print("key: ", foo, ", value: ", bar)
print ("...Reached the end...")

Dans la première boucle for, nous parcourons le dictionnaire en utilisant la clé seule. Dans la deuxième boucle for, la clé et la valeur sont utilisées comme variables d’itération pour itérer sur les éléments du dictionnaire nommé « studentDict ». Notez qu’il n’est pas obligatoire de mentionner le nom comme ‘clé’ et ‘valeur’ toujours dans la boucle for et pour le démontrer, nous avons utilisé foo et bar.

La sortie pour le code ci-dessus sera :

Itération sur un dictionnaire Itération à l’aide d’une seule clé dans la boucle for : john key: studentId , value: 415312 key: lastName , value: Smith key: age , value: 29 …Atteint la fin…

Itération sur une séquence à l’aide d’un index et d’une plage

Ceci est similaire aux boucles for que nous voyons dans des langages comme C/C++/Java etc. Les éléments d’une séquence donnée sont accessibles en utilisant index.

La fonction range() permet de renvoyer une plage de valeurs allant de zéro comme borne inférieure à la valeur mentionnée en paramètre dans la borne supérieure. Il est possible d’obtenir une sous-gamme en mentionnant une borne inférieure et une borne supérieure.

Par exemple, range(2,6) renvoie 2, 3, 4, 5 tandis que range(3) renverra 0, 1, 2. Dans le code suivant, nous utilisons range(len(rhymes)) pour diriger python pour parcourir positions 0, 1, 2, jusqu’aux rimes[length – 1] et imprimer les valeurs.

#!/usr/bin/python3
rhymes = ['Mary','Had','A','Little','Lamb']

print("Printing each word in new line accessed by index.")
for index in range(len(rhymes)):
    print (rhymes[index])

La sortie pour le code ci-dessus sera :

Faites défiler pour continuer

Impression de chaque mot dans une nouvelle ligne accessible par index. Mary avait un petit agneau

La boucle While

La syntaxe générale de la boucle while peut être représentée comme suit :

while condition:
    # do these steps

Il exécute à plusieurs reprises les étapes tant que la condition est vraie. Ainsi, une boucle infinie peut être facilement écrite en utilisant cette boucle while, tout comme nous la créons en C/C++/Java en utilisant :

test = 1
while test == 1:
    # do these steps infinite number of times

Dans le programme suivant, nous imprimons les nombres de 11 à 20 en utilisant une simple boucle while.

#!/usr/bin/python3

print("Counting from 11 to 20")
count = 11
while count<=20:
    print(count)
    count = count + 1

La sortie du programme ci-dessus sera la suivante :

Compter de 11 à 20 11 12 13 14 15 16 17 18 19 20

Boucles imbriquées

Il est possible d'imbriquer une boucle dans une autre boucle. Considérez l'exemple de programme suivant. Il est conçu pour imprimer une pyramide des nombres de la manière suivante :

1 1 2 1 2 3 … 1 2 3 … n

#!/usr/bin/python3

# Program to print a number pyramid like:
for i in range(1,6):
    for j in range(1, i+1):
        print (j, end=" ")
    print("")

Dans la première boucle for, nous spécifions la limite inférieure de la plage à 1 et la limite supérieure à 5+1. Dans la deuxième boucle, nous spécifions la plage de 1 à i+1 pour chaque ligne. Notez que l'instruction print a un paramètre nommé end=" ".

Il s'agit de demander à l'interpréteur d'imprimer d'autres sorties sur la même ligne et toutes ces sorties doivent être séparées à l'aide du caractère spécial affiché. Si l'instruction est modifiée en print (j, end=", "), tous les nombres auront une virgule finale. La sortie du programme ci-dessus sera :

1 1 2 1 2 3 1 2 3 4 1 2 3 4 5

Instructions de contrôle de boucle

Python propose trois instructions de contrôle :

Déclaration de rupture : Il termine l'instruction de boucle et transfère le contrôle en dehors de la portée à l'instruction suivante suivant la boucle.
Continuer la déclaration : Cela fait que la boucle saute les étapes restantes de la boucle mais continue avec l'itération suivante.
Déclaration de réussite : Il est souvent utile pour déboguer le code. Rien ne se passe vraiment lorsque l'instruction est exécutée.

Apprenons-en plus sur ces déclarations avec un exemple :

#!/usr/bin/python3
print('Printing letters in Welcome till letter l')
for letter in 'Welcome':
    if letter == 'l':
        break
    print (letter, end=", ")
    
print("")
print('Printing letters in welcome after omitting l')
for letter in 'Welcome':
    if letter == 'l':
        continue
    print (letter, end=", ")
print(" ")
print("Adding pass block when l is encountered")
for letter in 'Welcome':
    if letter == 'l':
        pass
        print(" ")
        print("Encountered pass block")
        print("Continue printing")
    print (letter, end=", ")

La sortie du code ci-dessus sera la suivante :

Imprimer des lettres dans Welcome jusqu'à la lettre l W, e, Imprimer des lettres dans welcome après avoir omis l W, e, c, o, m, e, Ajouter un bloc de passage lorsque l est rencontré W, e, Bloc de passage rencontré Continuer l'impression l, c, oncle,