Tutoriel sur les boucles en Python

Pour la boucle

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 à quelque chose que vous faites un certain nombre de fois.

Si vous gardez tout ce qui précède à l'esprit, vous pouvez facilement définir la boucle for comme suit :

Une boucle for est un concept de programmation qui, lorsqu'il est mis en œuvre, exécute un morceau de code encore et encore "for" un certain nombre de fois, sur la base d'une séquence.

Contrairement à la boucle while, aucune condition n'est activement impliquée - vous exécutez simplement un morceau de code de manière répétée pendant un certain nombre de fois. En d'autres termes, alors que la boucle while continue d'exécuter le bloc de code qu'elle contient jusqu'à ce que la condition soit remplie ( True), la boucle for n'exécute le code qu'elle contient que pendant un certain nombre de fois. Ce "nombre de fois" est déterminé par une séquence ou une liste ordonnée de choses.

Vous en apprendrez plus 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 que vous avez vus dans la section précédente reviennent 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 voulez exécuter plusieurs fois, print("Thank you").

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

Prenons 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 voir, vous démarrez la boucle avec 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. En outre, vous voyez 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 voulez exprimer que pour chaque index de la plage len(languages), vous voulez imprimer le langage de programmation de la science des données. Or, len(languages) est égal à 5, de sorte que l'énoncé peut é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 vous obtenez à nouveau le même résultat !

Boucles While et For en Python

Reprenons le tout premier exemple de boucle while pour déterminer quelles sont les différences exactes entre les boucles while et for. Vous avez déjà lu plus haut 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 passer de l'un à 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 la boucle for pour imprimer la déclaration "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

Vous voyez comme il est facile de convertir la boucle while en une boucle for équivalente ?

Comment cela fonctionne-t-il ? C'est simple.

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

Notez que le décompte de la fonction range() commence à 0 et non à 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. Ainsi, lorsque vous concevez une boucle for, gardez toujours à l'esprit que vous devez prendre en compte le compte de la plage à partir de 0 et non à partir de 1.

Astuce: il en va de même pour les listes en Python, par exemple. Si vous souhaitez en savoir plus sur les listes en Python, vous pouvez consulter le tutoriel de DataCamp sur les 18 questions les plus courantes concernant les listes en Python.

Il existe une autre différence intéressante entre une boucle for et une boucle while. Une boucle for est plus rapide qu'une boucle while. Pour comprendre cela, vous devez 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 morceau de code ci-dessus, vous avez deux boucles avec environ 10000 itérations. Les deux se ressemblent à première vue, jusqu'à ce que vous regardiez derrière les coulisses et que vous compreniez comment ces deux boucles fonctionnent. Indice : la fonction timeit() vous donne un indice sur ce qui pourrait être la différence !

Rappelez-vous: tout le code Python est compilé avec un compilateur C, ce qui signifie que le code que vous voyez ci-dessus est d'abord décomposé en codes d'octets, puis traité par le compilateur C sous-jacent.

Lorsque l'exécution de la boucle for de l'exemple ci-dessus commence, l'interprète Python communique avec le compilateur C sous-jacent et crée un objet liste de taille 10000. Ensuite, il appelle un itérateur pour toucher l'index de chacun des 10000 éléments de la liste.

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

Vous pouvez déjà imaginer qu'il est plus facile pour le compilateur d'itérer sur un objet liste déjà créé avec 10000 éléments que d'effectuer une opération booléenne de manière répétée pendant 9999 fois, la performance temporelle d'une boucle for est meilleure que celle d'une boucle while. Cela se reflète clairement dans le temps d'exécution : le temps nécessaire à l'achèvement de la boucle for est beaucoup plus court que le temps nécessaire à l'achèvement de la boucle while.

Essayez maintenant la boucle for ! Notez que vous devez spécifier la plage de 0 à 11, car vous souhaitez afficher uniquement les numéros de la séquence jusqu'à 55, qui est le 11e numéro de la séquence.

Boucles imbriquées

Comme vous pouvez le constater dans l'exemple ci-dessus, la boucle while contient une condition if-else qui vous permet d'introduire d'autres conditions dans votre code.

Attendez !

Ce n'est pas la seule façon de personnaliser votre boucle. Vous pouvez également inclure d'autres boucles while dans votre code existant, c'est ce qu'on appelle une boucle imbriquée. Vous pouvez modifier l'exemple ci-dessus pour inclure une autre boucle while comme 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, une autre boucle while est "imbriquée" dans la boucle externe, cette boucle interne vérifie une nouvelle fois si le site number % (mod) 2 est 0.

En d'autres termes, il vérifie si le nombre est pair et imprime la déclaration "Le nombre est pair".

Mais il y a un hic : si vous regardez de près, vous pouvez voir que, comme dans le code précédent, l'instruction number=number+1 est absente cette fois-ci. Comme vous n'incrémentez le numéro de la variable nulle part, la valeur de la variable reste la même à chaque fois et le code entre dans une boucle infinie. Cela signifie qu'une fois entré dans la boucle, il n'en sortira jamais et imprimera l'instruction un nombre infini de fois car la variable number sera toujours fixée à 2. Ce nombre est, bien entendu, inférieur à 5 et est un nombre pair.

Voyons maintenant à quoi ressemble 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. Notez qu'une deuxième boucle for est utilisée à l'intérieur de la boucle extérieure.

Allez-y et exécutez 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 imprimée, puis le contrôle entre dans la deuxième boucle for, où la valeur de la variable another_number est initialisée à 0. La première instruction print de la deuxième boucle for est imprimée une fois.

Maintenant, le contrôle revient à la boucle for interne et la valeur de another_number est à nouveau initialisée à l'entier suivant, suivie de l'impression de la déclaration à l'intérieur de la fonction print().

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

Ce voyage du contrôle à partir de la boucle la plus éloignée, traversant la boucle intérieure et revenant ensuite à la boucle for extérieure se poursuit jusqu'à ce que le contrôle ait couvert l'ensemble de la plage, c'est-à-dire trois fois dans votre cas.

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

break et continue Mots-clés : Créer des boucles infinies

Vous pouvez utiliser break et continue dans n'importe quelle boucle que vous créez. Ces mots-clés ne sont pas limités à la rupture des boucles infinies intentionnelles, mais ils doivent être utilisés avec précaution. Ces deux mots-clés rendent plus difficile pour les autres - y compris pour vous-même dans quelques mois lorsque vous reviendrez sur votre code - la compréhension du flux de contrôle dans la boucle et de l'endroit où la condition se termine. En outre, vous ne devez pas utiliser les mots-clés break et continue: comme vous l'avez vu jusqu'à présent, vous vous en passiez très bien !

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

Interrompre et poursuivre les boucles While en Python

Heureusement, il existe un moyen de sortir de cette situation de boucle infinie 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.

"C'est quoi cette sorcellerie ? s'écrie-t-on. - Détendez-vous, ce n'est pas de la sorcellerie.

Lorsque le contrôle rencontre le mot-clé break, il comprend qu'il doit sortir de la boucle (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 à faire ce qu'il fait habituellement jusqu'à ce que la condition de la boucle while externe soit vraie.

Vous devez tenir compte du fait qu'une ligne de code doit exister après le mot-clé break, sinon cela n'aura aucun effet. Essayez de supprimer la ligne de code après le mot-clé break dans l'exemple ci-dessus, puis exécutez le code.

Et si vous insériez le mot-clé continue après la déclaration break? Vous pouvez suivre le code ci-dessous :

# Take user input
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 rencontrez à nouveau une boucle infinie. Avant de vous arracher les cheveux de frustration, regardez 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 éloignée avant même que la variable number ne soit incrémentée, ce qui fait que le code entre dans une boucle infinie.

Rupture et poursuite des boucles For

Que se passerait-il si vous ne vouliez pas exécuter la boucle for interne de l'exemple ci-dessus pour l'ensemble de la plage ? Vous pouvez utiliser une déclaration break de la même manière que 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ôle de se détacher de la boucle interne, après quoi le contrôle retourne à la boucle externe.

Exécutez 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 extérieure est exécutée et le contrôle ne touche même pas la boucle intérieure.

"Pourquoi ?

Examinez le code de plus près. Il y a un mot-clé continue juste après la deuxième instruction print dans la boucle la plus éloignée. Ce qu'il fait, c'est qu'il demande au contrôle de revenir à la boucle for externe et de recommencer, et c'est la raison pour laquelle le contrôle ne touche jamais la boucle interne.

Contrairement à la boucle while, vous n'avez pas besoin d'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 rapport à xrange()

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

Pour comprendre en quoi ces deux fonctions sont similaires, considérez 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 verrez que la valeur de la variable number est sautée d'un facteur 2, et ce en raison des 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 à compter. Le deuxième paramètre est le paramètre d'arrêt qui est le point où le contrôle doit s'arrêter et le dernier paramètre est la fonction de pas, qui définit le facteur par lequel le contrôle doit sauter pendant le comptage.

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

Vous avez appris comment la fonction range() est utilisée pour définir le nombre de fois que votre code doit être bouclé. Dans Python 2.x, vous trouverez une autre façon de procéder, à savoir la fonction xrange(). Exécutez 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 voyez-vous dans la sortie du code ci-dessus par rapport à la sortie du code sans la fonction xrange()? Aucune différence ?

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

Pourquoi utiliser la fonction xrange()? Vous y reviendrez un peu plus loin dans ce tutoriel. Exécutez d'abord le code ci-dessous :

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

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

Vous pouvez voir que dans le résultat du code ci-dessus, il y a une différence dans le résultat des deux instructions d'impression. Dans l'instruction print, qui contient la fonction xrange(), l'objet de la fonction xrange() est imprimé. Il en va différemment dans l'instruction print qui comporte la fonction range(): vous obtenez alors une liste d'entiers de 0 à 9.

C'est exactement ce qui différencie la fonction range() de la fonction xrange().

Lorsque vous définissez la fonction range(), une liste de toute la gamme est stockée dans la RAM et vous est présentée. Toutefois, lorsque vous définissez la fonction xrange(), aucune liste n'est enregistrée dans la mémoire. Au lieu de cela, la fonction xrange() génère des nombres entiers dans l'ensemble de la plage lorsque vous en avez besoin. Ainsi, la fonction xrange() permet de conserver la mémoire dans un système à court de ressources.

Améliorez vos compétences en Python !

Félicitations, vous avez atteint la fin de ce tutoriel. Maintenant que vous avez appris à utiliser les boucles en Python, passez à la pratique. Plus vous pratiquez, mieux c'est !