Tutoriel sur les boucles Python

Boucle « for »

Vous pouvez aborder la boucle for de la même manière que la boucle while. Comme vous vous en doutez probablement, le composant « for » dans « for loop » fait référence à une action que vous effectuez un certain nombre de fois.

En gardant à l'esprit tous les éléments ci-dessus, vous pouvez facilement définir la boucle « for » comme suit :

Une boucle « for » est un concept de programmation qui, lorsqu'il est implémenté, exécute un morceau de code à plusieurs reprises « for » un certain nombre de fois, en fonction d'une séquence.

Contrairement à la boucle while, aucune condition n'est activement impliquée : vous exécutez simplement un morceau de code plusieurs fois de suite. En d'autres termes, alors que la boucle while continue d'exécuter le bloc de code qu'elle contient uniquement tant que la condition est True, la boucle for n'exécute le code qu'elle contient qu'un nombre spécifique de fois. Ce « nombre de fois » est déterminé par une séquence ou une liste ordonnée d'éléments.

Vous en apprendrez davantage sur la différence entre les boucles while et for dans un instant, mais pour l'instant, concentrez-vous sur les éléments suivants dont vous avez besoin pour créer une boucle for :

• Le mot-clé for
• Une variable
• Le mot-clé in
• La fonction range(), qui est une fonction intégrée à la bibliothèque Python permettant de créer une séquence de nombres.
• Le code que vous souhaitez exécuter de manière répétée

Boucles « for » en Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

# Thank you
# Thank you
# Thank you
# Thank you
# Thank you

Comme vous pouvez le constater, les composants présentés dans la section précédente sont repris dans ce petit exemple de boucle « for » en Python : le mot-clé for, la variable number, le mot-clé in, la fonction range() et le code que vous souhaitez exécuter plusieurs fois, print("Thank you").

Ce n'est pas si difficile, n'est-ce pas ?

Examinons un autre exemple de boucle « for », dans lequel vous utilisez deux variables pour définir votre flux de contrôle :

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

Comme vous pouvez le constater, la boucle débute par le mot-clé for. Ensuite, vous utilisez les variables index et languages, le mot-clé in et la fonction range() pour créer une séquence de nombres. De plus, vous pouvez constater que vous utilisez également la fonction len() dans ce cas, car la liste languages n'est pas numérique. Le morceau de code que vous souhaitez exécuter de manière répétée est une instruction d'impression, à savoir : print('Current language :', languages[index]).

Dans la boucle ci-dessus, vous souhaitez exprimer que pour chaque index compris dans la plage len(languages), vous souhaitez afficher le langage de programmation en science des données. Maintenant, len(languages) est égal à 5, donc l'énoncé pourrait également être réécrit comme suit :

for index in range(5):
    print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

Et cela vous donne à nouveau le même résultat !

Boucles « while » et « for » en Python

Revenons à l'exemple initial de boucle while afin de déterminer précisément les différences entre les boucles while et for. Vous avez déjà lu ci-dessus que la différence réside dans la condition qui est ou n'est pas impliquée, mais comment cela se reflète-t-il dans le code et comment pouvez-vous éventuellement passer de l'une à l'autre ?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

# Thank you
# Thank you
# Thank you

Vous pouvez utiliser une boucle « for » pour afficher le message « Merci » de manière plus contrôlée :

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

# Thank you
# Thank you
# Thank you

Avez-vous remarqué à quel point il était simple de convertir la boucle « while » en une boucle « for » équivalente ?

Comment cela fonctionne-t-il, demandez-vous ? C'est très simple.

Dans une boucle for, l'entier mentionné dans la fonction range correspond à la plage ou au nombre de fois que le contrôle doit boucler et exécuter le code dans la clause de la boucle for.

Veuillez noter que la fonction d'range() commence à compter à partir de 0 et non à partir de 1. Cela signifie que, dans l'exemple ci-dessus, le décompte devrait être 0,1,2 et non 1,2,3. C'est ainsi que fonctionne le comptage des nombres dans la mémoire d'un ordinateur. Par conséquent, lorsque vous concevez une boucle « for », veuillez toujours garder à l'esprit que vous devez considérer le nombre de la plage à partir de 0 et non à partir de 1.

Remarque: cela s'applique également aux listes en Python, par exemple. Si vous souhaitez en savoir plus sur les listes Python, nous vous recommandons de consulter le tutoriel de DataCamp intitulé « Les 18 questions les plus courantes sur les listes Python ».

Il existe une autre différence notable entre une boucle « for » et une boucle « while ». Une boucle « for » est plus rapide qu'une boucle « while ». Pour mieux comprendre, veuillez examiner l'exemple ci-dessous.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

# 267.0804728891719

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

# 884.9233417965908

Dans le bloc de code ci-dessus, vous avez deux boucles avec environ 10 000 itérations. À première vue, les deux semblent identiques, jusqu'à ce que l'on examine les coulisses et que l'on comprenne comment ces deux boucles fonctionnent. Remarque : la fonction timeit() vous fournit un indice sur ce qui pourrait constituer la différence.

Veuillez noter que tout le code Python est compilé à l'aide d'un compilateur C, ce qui signifie que le code présenté ci-dessus est d'abord décomposé en codes octets, puis traité par le compilateur C sous-jacent.

Lorsque l'exécution de la boucle for dans l'exemple ci-dessus commence, l'interpréteur Python communique avec le compilateur C sous-jacent, puis crée un objet liste de taille 10 000. Ensuite, il fait appel à un itérateur pour examiner l'index de chacun des 10 000 éléments de la liste.

L'exécution de la boucle while, en revanche, ne crée aucun objet liste. En réalité, le compilateur C sous-jacent appelle 9999 fois l'opérateur de comparaison booléen pour la condition i<10000.

Vous pouvez déjà imaginer qu'il est plus facile pour le compilateur d'itérer sur un objet liste déjà créé contenant 10 000 éléments que d'effectuer une opération booléenne 9 999 fois. La performance temporelle d'une boucle « for » est supérieure à celle d'une boucle « while ». Cela se reflète clairement dans le temps d'exécution : le temps nécessaire à la boucle « for » pour s'exécuter est considérablement plus court que celui requis par la boucle « while ».

Veuillez maintenant tester la boucle « for » ! Veuillez noter que vous devez spécifier la plage de 0 à 11, car vous souhaitez afficher uniquement les nombres de la séquence jusqu'à 55, qui est le 11e nombre de la séquence.

Boucles imbriquées

Comme vous pouvez le constater dans l'exemple ci-dessus, il existe une condition if-else à l'intérieur de la boucle while qui vous permet d'introduire des conditions supplémentaires dans votre code.

Veuillez patienter un instant.

Ce n'est pas la seule façon de personnaliser votre boucle. Vous pouvez également inclure plusieurs boucles while dans votre code existant, ce qui est appelé une boucle imbriquée. Vous pouvez modifier l'exemple ci-dessus pour inclure une autre boucle while comme indiqué ci-dessous :

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

Dans l'exemple ci-dessus, il existe une autre boucle while qui est « imbriquée » dans la boucle externe. Cette boucle interne effectue une autre vérification pour déterminer si l'number % (mod) 2 est 0.

En d'autres termes, il vérifie si le nombre est pair, puis affiche la déclaration « Le nombre est pair ».

Cependant, il y a un problème : si vous observez attentivement, vous remarquerez que, comme dans le code précédent, l'instruction number=number+1 est absente cette fois-ci. Étant donné que vous n'incrémentez la variable number nulle part, sa valeur reste la même à chaque fois et le code entre dans une boucle infinie. Cela signifie qu'une fois qu'il entre dans la boucle, il ne la quitte jamais et imprime l'instruction un nombre infini de fois, car la variable number sera toujours définie sur 2. Ce nombre est, bien entendu, inférieur à 5 et pair.

Examinons maintenant à quoi ressemblerait une boucle for imbriquée :

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

Le code ci-dessus est une version modifiée du premier exemple de boucle for. Veuillez noter qu'une deuxième boucle « for » est utilisée à l'intérieur de la boucle externe.

Veuillez exécuter le code.

Vous constaterez que le contrôle entre dans la première boucle for et que la valeur de la variable number est initialisée à 0. La première instruction d'impression est exécutée, puis le contrôle passe à la deuxième boucle « for », où la valeur de la variable another_number est initialisée à 0. La première instruction d'impression dans la deuxième boucle for est imprimée une fois.

À présent, le contrôle revient à la boucle for interne et la valeur de another_number est à nouveau initialisée à l'entier suivant, puis l'instruction à l'intérieur de la fonction print() est imprimée.

Le processus susmentionné se poursuit jusqu'à ce que le contrôle ait traversé la fin de la fonction d'range(), qui est 5 dans ce cas, puis le contrôle revient à la boucle la plus externe, initialise la variable number à l'entier suivant, imprime l'instruction à l'intérieur de la fonction d'print(), visite la boucle interne, puis répète toutes les étapes ci-dessus jusqu'à ce que la fonction d'range() e soit traversée.

Ce parcours du contrôle, qui part de la boucle la plus externe, traverse la boucle interne, puis revient à la boucle externe, se poursuit jusqu'à ce que le contrôle ait couvert toute la plage, soit trois fois dans votre cas.

Maintenant que vous avez lu quelques explications sur les boucles imbriquées, il est temps de vous lancer ! Écrivez un programme Python pour construire le modèle suivant, en utilisant une boucle for imbriquée :

break et continue Mots clés : Création de boucles infinies

Vous pouvez utiliser les balises break et continue dans n'importe quelle boucle que vous créez. Ces mots-clés ne sont pas limités à la rupture de boucles infinies intentionnelles, mais ils doivent être utilisés avec précaution. Ces deux mots-clés compliquent la compréhension du flux de contrôle dans la boucle et de la fin de la condition pour les autres, y compris pour vous-même lorsque vous reviendrez sur votre code dans quelques mois. De plus, il n'est pas nécessaire d'utiliser les mots-clés break et continue: comme vous avez pu le constater jusqu'à présent, vous vous en sortiez parfaitement bien sans eux !

Cependant, dans certains cas, il peut être plus clair d'écrire des boucles infinies intentionnelles plutôt que les boucles for et while traditionnelles que vous avez observées jusqu'à présent. Bien entendu, dans ces cas-là, l'utilisation de ces mots-clés est vivement recommandée.

Interruption et poursuite des boucles while en Python

Heureusement, il existe un moyen de sortir de la situation de boucle infinie décrite ci-dessus, à savoir en utilisant le mot-clé break.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Lorsque vous exécutez le code ci-dessus, il n'entre plus dans une boucle infinie.

« Quelle est cette sorcellerie ? » vous vous exclamerez. - Je vous répondrai : « Détendez-vous, ce n'est pas de la sorcellerie. »

Lorsque le contrôleur rencontre le mot-clé break, il comprend qu'il doit quitter la boucle (la boucle interne dans ce cas) et exécute la ligne de code suivante. Il sort donc de la boucle while interne et passe à la boucle externe, où il continue à exécuter ses tâches habituelles jusqu'à ce que la condition de la boucle while externe soit vraie.

Il est important de noter qu'une ligne de code doit suivre le mot-clé break, sinon celui-ci n'aura aucun effet. Veuillez supprimer la ligne de code après le mot-clé break dans l'exemple ci-dessus, puis exécutez le code.

Que se passerait-il si vous insériez le mot-clé continue après l'instruction break ? Vous pouvez suivre le code ci-dessous :

number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

Le code ci-dessus est une version légèrement modifiée de l'exemple du mot-clé break.

Lorsque vous exécutez le code ci-dessus, vous rencontrerez à nouveau une boucle infinie. Avant de vous arracher les cheveux de frustration, examinez la situation de plus près. Vous remarquerez qu'il y a un mot-clé continue après la pause. Le mot-clé continue transfère le contrôle à la boucle la plus externe avant même que la variable number ne soit incrémentée, ce qui entraîne une boucle infinie.

Interruption et poursuite des boucles « for »

Que faire si vous ne souhaitez pas exécuter la boucle for interne dans l'exemple ci-dessus pour l'ensemble de la plage ? Vous pouvez utiliser une instruction break de la même manière que vous l'avez fait dans le cas de la boucle « while ».

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Dans l'exemple ci-dessus, le mot-clé break après la boucle interne indique au contrôleur de sortir de la boucle interne, après quoi le contrôleur revient à la boucle externe.

Veuillez exécuter l'exemple de code ci-dessous :

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Dans le code ci-dessus, seule la boucle la plus externe est exécutée et le contrôle ne touche même pas la boucle interne.

« Pourquoi ? » demandez-vous.

Veuillez examiner attentivement le code. Il y a un mot-clé continue juste après la deuxième instruction « print » dans la boucle la plus externe. Il indique au contrôleur de revenir à la boucle for externe et de recommencer, ce qui explique pourquoi le contrôleur n'atteint jamais la boucle interne.

Contrairement à la boucle while, il n'est pas nécessaire d'inclure un morceau de code après le mot-clé break dans la boucle for. Une boucle break seule fonctionnera parfaitement à l'intérieur d'une boucle for.

range() par opposition à xrange()

Ces deux fonctions sont similaires, mais si vous utilisez Python 3, seule la fonction range() sera disponible. Dans Python 3.x, la fonction xrange() a été renommée en range(). Cela signifie que si vous essayez d'utiliser la fonction xrange() avec Python 3, vous obtiendrez une erreur d'NameError: name 'xrange' is not defined.

Pour mieux appréhender les similitudes entre ces deux fonctions, veuillez examiner l'exemple suivant :

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

# I am number : 5
# I am number : 7
# I am number : 9

En exécutant le code ci-dessus, vous constaterez que la valeur de la variable number est multipliée par deux, ce qui est dû aux paramètres de la fonction range().

Le premier paramètre de cette fonction est le paramètre de départ. C'est à partir de ce point que le contrôle commence à être compté. Le deuxième paramètre est le paramètre d'arrêt, qui correspond au point où la commande doit s'arrêter, et le dernier paramètre est la fonction de pas, qui définit le facteur par lequel la commande doit sauter pendant le comptage.

Ainsi, dans le cas ci-dessus, le contrôle commence à 5, puis parcourt la boucle jusqu'à 9 tout en ajoutant 2 à chaque comptage. Cela signifie 5, 5 + 2 = 7, 7 + 2 = 9.

Vous avez appris comment utiliser la fonction range() pour définir le nombre de fois que votre code doit s'exécuter en boucle. Dans Python 2.x, il existe également une autre méthode pour réaliser cette opération, à savoir la fonction xrange(). Veuillez exécuter le code ci-dessous :

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

Quelle différence avez-vous constatée entre le résultat du code ci-dessus et celui du code sans la fonction d'xrange()? Aucune différence ?

C'est exact. Vous ne constaterez aucune différence dans le résultat du code.

Par conséquent, pourquoi est-il recommandé d'utiliser la fonction xrange()? Vous y parviendrez un peu plus tard dans le tutoriel. Veuillez d'abord exécuter le code ci-dessous :

print(xrange(10))
print(range(10))

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Vous pouvez observer que dans le résultat du code ci-dessus, il existe une différence entre les résultats des deux instructions d'impression. Dans l'instruction d'impression, qui contient la fonction d'xrange(), vous obtenez l'objet de la fonction d'xrange() imprimé. Ceci diffère dans l'instruction print qui utilise la fonction d'range(): dans ce cas, vous obtenez une liste d'entiers allant de 0 à 9.

C'est précisément ce qui distingue la fonction range() de la fonction xrange().

Lorsque vous définissez la fonction d'range(), une liste de l'ensemble de la plage est enregistrée dans la mémoire RAM et vous est présentée. Cependant, lorsque vous définissez la fonction d'xrange(), aucune liste n'est stockée dans la mémoire. Au lieu de cela, la fonction xrange() génère des nombres entiers dans toute la plage lorsque cela est nécessaire. De cette manière, la fonction d'xrange() permet de préserver la mémoire dans les systèmes disposant de ressources limitées.

Perfectionnez vos compétences en Python !

Félicitations, vous avez terminé ce tutoriel. Maintenant que vous avez appris à utiliser les boucles en Python, nous vous invitons à vous exercer. Plus vous vous entraînez, mieux c'est.