Boucles For en Python : Tout ce que vous devez savoir

Ce tutoriel vous apprendra tout sur l'utilisation des boucles pour en Python avec des exemples de code.

En programmation, les boucles vous aident à répéter un ensemble spécifique d'instructions. Vous utiliserez les boucles for pour des itérations définies lorsque :

• vous savez que vous travaillerez avec une séquence comportant un nombre fini d'éléments
• vous connaissez à l'avance le nombre de répétitions

Ce tutoriel vous apprendra tout sur l'utilisation des boucles for en Python. Vous commencerez par apprendre la syntaxe et les itérations simples en utilisant une boucle for. Ensuite, vous apprendrez à traiter les arguments de ligne de commande, à utiliser les instructions de contrôle de boucle, et plus encore.

Commençons .

Syntaxe de la boucle pour de Python

La syntaxe générique de la boucle pour en Python est la suivante :

for item in iterable :
 # faire quelque chose sur l'élément
 statement_1
 statement_2
.
.
.
 statement_n

Dans la syntaxe ci-dessus :

• article est la variable de bouclage.
• itérable désigne tout itérable Python tel que les listes, les tuples et les chaînes de caractères.
• déclaration_1 à déclaration_n désignent les instructions dans le corps de la boucle.

Remarque: veillez à ajouter deux points (:) après le nom de l'itérable et à indenter toutes les instructions du corps de la boucle de quatre espaces.

Constructions courantes des boucles for en Python

Lorsque vous utilisez une boucle for:

• Vous pouvez accéder directement aux éléments en utilisant la syntaxe décrite dans la section précédente.
• Vous pouvez utiliser la boucle for en conjonction avec les fonctions intégrées de Python telles que range() et enumerate().

Nous les aborderons dans cette section.

Utilisation de la boucle for pour accéder aux éléments

Pour améliorer la lisibilité, vous devez choisir une variable de boucle indiquant ce que la liste contient. Par exemple, dans l'exemple ci-dessous, nums est une liste de nombres et nous utilisons num comme variable de bouclage. Remarquez que for num in nums : est intuitif et facile à lire.

nums = [4,5,9,1,3]
for num in nums :
 print(num)

# Sortie
4
5
9
1
3

En ajoutant quelques autres exemples, vous pouvez utiliser for fruit in fruits : et for student in students : pour parcourir en boucle les listes de fruits et d'étudiants, respectivement.

Utilisation de la boucle for avec la fonction range()

Lorsque vous souhaitez accéder à un élément d'une liste par le biais de son index, vous pouvez utiliser la fonction range().

En Python, range(start, stop, step) renvoie un objet range, que vous pouvez parcourir en boucle pour obtenir les indices : start, start step, et ainsi de suite, jusqu'à stop inclus.

for i in range(len(nums)) :
 print(nums<x><x><x><x>[i]</x></x></x></x>)

# Output
4
5
9
1
3

Vous pouvez également utiliser la fonction range() pour générer une séquence de nombres à parcourir en boucle. Dans l'exemple ci-dessous, nous avons fixé le paramètre optionnel step à 2, ce qui nous permet d'obtenir des nombres compris entre 10 et 20 (non compris), par pas de 2.

for i in range(10,20,2) :
 print(i)

# Output
10
12
14
16
18

Utilisation de la boucle for avec la fonction enumerate()

Lorsque vous souhaitez parcourir en boucle un tableau itératif et accéder simultanément aux éléments et à leurs indices, vous pouvez utiliser la fonction enumerate().

Voici un exemple.

for idx, num in enumerate(nums) :
 print(f"{idx}:{num}")

# Output
0:4
1:5
2:9
3:1
4:3

Comment lire les éléments d'une liste à l'aide de la boucle for en Python ?

Pour parcourir des listes Python à l'aide de la boucle for, vous pouvez utiliser la syntaxe générique de la section précédente.

Dans l'exemple ci-dessous, nums est un itérable et num est la variable de bouclage.

nums = [4,5,9,1,3]
for num in nums :
 print(f"{num} times 3 is {num*3}") # action sur chaque num

# Output
4 times 3 is 12
5 times 3 is 15
9 times 3 is 27
1 times 3 is 3
3 times 3 is 9

Comment boucler des chaînes de caractères en utilisant la boucle for en Python

Les chaînes de caractères Python sont des itérables et vous pouvez effectuer des opérations de bouclage, d'indexation, de découpage, etc.

Remarque: Python n'a pas de type de données intégré pour les caractères. Vous pouvez donc traiter un caractère comme une chaîne de longueur 1.

my_string = "Code"
for char in my_string :
 print(char)

# Output
C
o
d
e

Comment effectuer des boucles dans des tableaux à l'aide de la boucle for en Python

Vous pouvez parcourir des tableaux en utilisant des boucles et des boucles for imbriquées.

Dans l'extrait de code ci-dessous, array1 est une liste imbriquée dont les éléments sont des listes plus petites. Ainsi, en bouclant sur array1, vous obtenez chaque ligne, comme indiqué ci-dessous.

array1 = [[2,3],[7,8]]
for row in array1 :
 print(row)

# Output
[2, 3]
[7, 8]

Pour accéder aux éléments individuels de chaque ligne, vous pouvez utiliser une autre boucle for.

array1 = [[2,3], [7,8]]
for row in array1 :
 for elt in row :
 print(elt)

Dans la cellule de code ci-dessus :

• La boucle externe vous aide à indexer les lignes.
• La boucle pour interne vous permet d'accéder aux éléments de chaque ligne.

Voici la sortie correspondante.

Résultat
2
3
7
8

Comment lire les arguments de la ligne de commande à l'aide de la boucle for ?

En tant que développeur, vous devez être à l'aise pour exécuter des scripts Python à partir de la ligne de commande et utiliser les arguments de la ligne de commande pour interagir avec votre script.

Vous pouvez utiliser les modules intégrés de Python, tels que sys et argparse, pour analyser et lire les arguments de la ligne de commande.

Dans cette section, nous verrons comment utiliser le module sys et une boucle for pour parcourir la liste des arguments de la ligne de commande.

Dans le module sys, sys.argv est la liste des arguments de la ligne de commande que vous transmettez. Vous pouvez donc parcourir sys.argv comme vous le feriez avec n'importe quelle liste Python.

# main.py

import sys

for arg in sys.argv :
 print(arg)

Vous pouvez maintenant exécuter le programme à partir de la ligne de commande, comme indiqué ci-dessous.

python main.py Hello Python3
main.py
Hello
Python3

Par défaut, le nom du module est le premier argument et se trouve à l'index zéro dans sys.argv.

Si vous voulez accéder aux indices et aux arguments correspondants, vous pouvez utiliser la fonction range().

# main.py

import sys

for i in range(len(sys.argv)) :
 print(f "arg{i} is {sys.argv<x><x><x><x>[i]</x></x></x></x>}")

▶️ Ensuite, réexécutez main.py.

$ python main.py Hello Python3
arg0 is main.py
arg1 is Hello
arg2 is Python3

Supposons que vous souhaitiez analyser et traiter les arguments autres que le nom du module. Vous pouvez fixer la valeur de départ à 1, comme dans la cellule de code ci-dessous.

# main.py

import sys

for i in range(1,len(sys.argv)) :
 print(f "arg{i} is {sys.argv<x><x><x><x>[i]</x></x></x></x>}")

$ python main.py Hello Python3
arg1 is Hello
arg2 is Python3

En mettant tout cela ensemble, Le fichier main.py contient le code suivant.

# main.py

import sys

print("\nPrinting all command-line arguments...")
for arg in sys.argv :
 print(arg)

print("\nPrinting all command-line arguments with index...")
for i in range(len(sys.argv)) :
 print(f "arg{i} is {sys.argv<x><x><x><x>[i]</x></x></x></x>}")

print("\nPrinting command-line arguments except arg0 : module_name...")
for i in range(1,len(sys.argv)) :
 print(f "arg{i} is {sys.argv<x><x><x><x>[i]</x></x></x></x>}")

Voici la sortie lorsque vous exécutez le module.

$ python main.py Hello Python3

Impression de tous les arguments de la ligne de commande...
main.py
Hello
Python3

Impression de tous les arguments de la ligne de commande avec l'index...
arg0 is main.py
arg1 is Hello
arg2 is Python3

Impression des arguments de la ligne de commande sauf arg0 : nom_du_module...
arg1 is Hello
arg2 is Python3

Comment utiliser l'instruction break à l'intérieur d'une boucle for

Comme d'autres langages de programmation, Python prend également en charge l'utilisation des instructions de contrôle de boucle break et continue. Ces instructions permettent de modifier le flux de contrôle dans les boucles, en fonction de certaines conditions. Voyons comment les utiliser à l'intérieur d'une boucle for.

L'instruction break le peut être utilisé pour sortir d'une boucle lorsqu'une condition spécifique est vraie.

Nous voulons écrire un programme pour faire ce qui suit :

• Fixez k, le nombre d'entrées.
• Utilisez une boucle for pour lire les entrées des utilisateurs, un chiffre à la fois, et additionner les nombres non négatifs (supérieurs ou égaux à zéro).
• Ce processus doit se poursuivre tant que l'utilisateur entre des nombres non négatifs.
• Lorsque l'utilisateur entre un nombre négatif, quittez la boucle et imprimez la somme.

Voici le code qui exécute la tâche ci-dessus.

k= 5
sum = 0
for i in range(k) :
 num = int(input("\nEntrez un nombre : "))
 if num<0 :
 break # exit loop when num < 0
 sum = num

print(sum)

Si l'utilisateur entre un nombre inférieur à zéro, le contrôle sort de la boucle for et passe à la première instruction après la boucle.

Entrez un nombre : 2

Entrez un nombre : 3

Entrez un nombre : 5

Entrez un nombre : -1
10

Comment utiliser l'instruction continue à l'intérieur d'une boucle for

L'instruction continue peut être utilisée pour sauter certaines itérations en fonction d'une condition spécifique.

Reprenons les exemples de la section précédente.

• Lisez les données de l'utilisateur et calculez la somme des nombres non négatifs.
• Si l'utilisateur entre un nombre négatif, sautez cette itération, passez à l'itération suivante et lisez le nombre suivant.

k = 5
sum = 0
for i in range(k) :
 num = int(input("\nEntrez un nombre : "))
 if num<0 :
 continue
 sum = num

print(sum)

Voici un exemple de sortie.

Entrez un nombre : 2

Entrez un nombre : 3

Entrez un nombre : 5

Entrez un nombre : -1

Entrez un nombre : 3
13

Le quatrième nombre est -1, c'est-à-dire négatif. Cependant, cette fois, la boucle for continue jusqu'à ce que nous atteignions le nombre spécifié d'entrées, et ignore les entrées négatives. En fait, elle renvoie la somme de tous les nombres non négatifs des k nombres entrés.

Pouvez-vous rencontrer une boucle for infinie en Python ?

Dans tous les exemples et cas d'utilisation que nous avons discutés jusqu'à présent, nous n'avons jamais rencontré le problème d'une boucle for infinie. Mais peut-on avoir une boucle for infinie en Python ?

Considérez la fonction double() suivante.

def double(x = 1) :
 return x*2

• Lorsque vous appelez la fonction double() sans spécifier la valeur de x, la valeur par défaut de 1 est utilisée.
• Si vous spécifiez une valeur pour x dans l'appel de la fonction, c'est cette valeur qui est utilisée.

double()
# Retourne : 2

double(20)
# Retourne : 40

En Python, la fonction iter() renvoie un objet itérateur. Vous pouvez utiliser next(iter-obj) pour parcourir la séquence et accéder aux éléments suivants.

- Considérons un objet appelable et une valeur, sentinelle.

– iter(objet-appelable, sentinelle) peut être utilisé pour effectuer une itération jusqu'à ce que la valeur de retour de l'objet-appelable soit égale à sentinelle.

Voyez-vous pourquoi nous pouvons avoir une boucle for infinie dans ce cas ?

Vous avez un objet appelable et une valeur sentinelle. Si la valeur de retour de l'objet appelable n'est jamais égale à la sentinelle, la boucle se poursuit à l'infini !

Utilisons la fonction double ci-dessus comme objet appelable et fixons la valeur de la sentinelle à 0.

Remarque: mentionnez le nom de la fonction double, et non l'appel de la fonction double().

Comme la valeur de retour de la fonction double est toujours 2 et n'est jamais égale à 0, nous avons une boucle infinie !

▶️ Essayez d'exécuter la cellule de code suivante. Il s'agit d'une boucle infinie et vous devrez forcer l'arrêt du programme.

for _ in iter(double,0) :
 print("Running...")

Boucles de for Python : Questions pratiques

#1. Utilisez la boucle for pour imprimer tous les nombres pairs compris entre 0 et 20.

Astuce: Utilisez la fonction range() avec la bonne valeur de pas.

#2. Imprimez tous les nombres paires de 20 à 0.

Astuce: Utilisez une valeur négative pour le paramètre step dans la fonction range().

#3. Créez un tableau NumPy tridimensionnel.

Conseil: Utilisez des boucles for et des boucles for imbriquées si nécessaire pour accéder aux lignes et aux entrées individuelles du tableau.

Récapitulation

Voici un résumé de ce que vous avez appris dans ce tutoriel.

• La syntaxe pour utiliser la boucle for de Python avec les fonctions range() et enumerate()
• L'utilisation des boucles for pour parcourir des listes, des tableaux et des chaînes de caractères, et pour lire les arguments de la ligne de commande
• Utiliser les instructions de contrôle de boucle : break pour sortir de la boucle et continue pour sauter certaines itérations - en fonction des conditions - à l'intérieur des boucles for
• Comprendre la possibilité de boucles for infinies en Python

Apprenez ensuite à utiliser la méthode split() en Python.