Tout ce que tu as besoin de savoir

Maîtriser les boucles `for` en Python : Guide Complet

Ce guide didactique vous plongera au cœur des boucles `for` en Python, illustrées par des exemples de code concrets.

En programmation, les boucles sont des outils essentiels pour exécuter de manière répétée un ensemble d’instructions. Les boucles `for` sont particulièrement adaptées aux itérations définies, c’est-à-dire lorsque :

Vous savez que vous allez travailler sur une séquence dont le nombre d’éléments est connu.
Le nombre de répétitions est déterminé à l’avance.

Cet article vous offrira une vue d’ensemble complète de l’utilisation des boucles `for` en Python. Nous commencerons par la syntaxe de base et les itérations simples, avant d’aborder le traitement des arguments de ligne de commande, l’emploi des instructions de contrôle de boucle, et bien plus encore.

Entamons notre exploration…

Syntaxe d’une boucle `for` en Python

La structure générale d’une boucle `for` en Python est la suivante :

for element in iterable:
  # Effectuer une action sur l'élément
  instruction_1
  instruction_2
  ...
  instruction_n

Décortiquons cette syntaxe :

`element` est la variable qui prendra successivement les valeurs de chaque élément de l’itérable.
`iterable` représente tout objet Python itérable, comme les listes, tuples ou chaînes de caractères.
`instruction_1` à `instruction_n` sont les instructions à exécuter à chaque itération de la boucle.

Important : N’oubliez pas d’ajouter les deux points (:) après l’itérable et d’indenter toutes les instructions du corps de la boucle de quatre espaces.

Constructions courantes de boucles `for` en Python

Lors de l’utilisation d’une boucle `for` :

Vous pouvez accéder directement aux éléments de l’itérable en utilisant la syntaxe de base.
Vous pouvez combiner la boucle `for` avec des fonctions Python intégrées telles que `range()` et `enumerate()`.

Nous explorerons ces différentes approches ci-dessous.

Accéder aux éléments avec une boucle `for`

Pour une meilleure lisibilité, privilégiez une variable de boucle dont le nom reflète le contenu de la liste. Par exemple, dans le code ci-dessous, `nums` est une liste de nombres et la variable de boucle `num` est explicite et claire.

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

# Sortie
4
5
9
1
3

De manière similaire, nous pourrions écrire `for fruit in fruits:` ou `for étudiant in etudiants:` pour parcourir des listes de fruits ou d’étudiants, respectivement.

Utiliser la boucle `for` avec la fonction `range()`

Lorsque vous souhaitez accéder à un élément de liste par son index, la fonction `range()` est votre alliée.

En Python, `range(début, fin, pas)` renvoie un objet `range` qui génère une séquence d’indices : `début`, `début + pas`, etc., jusqu’à la valeur `fin` exclue.

for i in range(len(nums)):
  print(nums[i])

# Sortie
4
5
9
1
3

La fonction `range()` peut aussi servir à générer une série de nombres à itérer. Dans l’exemple ci-après, le pas est défini sur 2, ce qui permet d’obtenir les nombres de 10 à 20 (exclu) par incréments de 2.

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

# Sortie
10
12
14
16
18

Utiliser la boucle `for` avec la fonction `enumerate()`

La fonction `enumerate()` est idéale pour parcourir un itérable tout en ayant accès à la fois aux éléments et à leurs indices.

Voici un exemple illustratif :

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

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

Parcourir des listes avec une boucle `for`

Pour parcourir les listes Python à l’aide d’une boucle `for`, utilisez la syntaxe générale présentée précédemment.

Dans l’exemple ci-dessous, `nums` est l’itérable et `num` est la variable de boucle.

nums = [4, 5, 9, 1, 3]
for num in nums:
  print(f"{num} fois 3 est égal à {num*3}") 

# Sortie
4 fois 3 est égal à 12
5 fois 3 est égal à 15
9 fois 3 est égal à 27
1 fois 3 est égal à 3
3 fois 3 est égal à 9

Parcourir des chaînes avec une boucle `for`

Les chaînes de caractères en Python sont itérables, vous pouvez donc les parcourir, les indexer et les découper.

Note: Python n’a pas de type de données « caractère » spécifique. Un caractère est donc considéré comme une chaîne de longueur 1.

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

# Sortie
C
o
d
e

Parcourir des tableaux avec une boucle `for`

Vous pouvez utiliser des boucles imbriquées pour parcourir des tableaux multidimensionnels.

Dans l’exemple de code ci-dessous, `array1` est une liste de listes. Ainsi, une première boucle `for` sur `array1` itérera à travers chaque ligne.

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

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

Pour accéder à chaque élément individuel, vous pouvez utiliser une autre boucle `for` à l’intérieur de la première.

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

Ici :

La boucle `for` externe permet d’accéder à chaque ligne.
La boucle `for` interne permet d’accéder aux éléments de chaque ligne.

Voici la sortie résultante :

# Sortie
2
3
7
8

Récupérer les arguments de ligne de commande avec une boucle `for`

En tant que développeur, il est essentiel de pouvoir exécuter des scripts Python depuis la ligne de commande et d’utiliser des arguments pour interagir avec votre script.

Les modules intégrés tels que `sys` et `argparse` permettent d’analyser et de récupérer ces arguments.

Nous allons explorer comment utiliser le module `sys` et une boucle `for` pour parcourir les arguments de ligne de commande.

Dans le module `sys`, `sys.argv` est la liste des arguments passés en ligne de commande. Vous pouvez donc la parcourir comme n’importe quelle autre liste Python.

# main.py

import sys

for arg in sys.argv:
  print(arg)

Vous pouvez maintenant exécuter ce programme depuis la ligne de commande :

$ python main.py Bonjour Python3
main.py
Bonjour
Python3

Par défaut, le nom du module est le premier argument, à l’indice 0 dans `sys.argv`.

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

# main.py

import sys

for i in range(len(sys.argv)):
  print(f"arg{i} est {sys.argv[i]}")

▶️ Relancez `main.py`.

$ python main.py Bonjour Python3
arg0 est main.py
arg1 est Bonjour
arg2 est Python3

Si vous souhaitez analyser et traiter uniquement les arguments, hormis le nom du module, il est possible de commencer l’itération à partir de l’indice 1 :

# main.py

import sys

for i in range(1, len(sys.argv)):
  print(f"arg{i} est {sys.argv[i]}")

$ python main.py Bonjour Python3
arg1 est Bonjour
arg2 est Python3

Pour récapituler, voici le code complet dans le fichier `main.py` :

# main.py

import sys

print("nAffichage de tous les arguments de ligne de commande...")
for arg in sys.argv:
  print(arg)

print("nAffichage des arguments de ligne de commande avec leur index...")
for i in range(len(sys.argv)):
  print(f"arg{i} est {sys.argv[i]}")

print("nAffichage des arguments de ligne de commande sauf arg0: nom_du_module...")
for i in range(1, len(sys.argv)):
  print(f"arg{i} est {sys.argv[i]}")

Voici la sortie lors de l’exécution du module :

$ python main.py Bonjour Python3

Affichage de tous les arguments de ligne de commande...
main.py
Bonjour
Python3

Affichage des arguments de ligne de commande avec leur index...
arg0 est main.py
arg1 est Bonjour
arg2 est Python3

Affichage des arguments de ligne de commande sauf arg0: nom_du_module...
arg1 est Bonjour
arg2 est Python3

Utiliser l’instruction `break` à l’intérieur d’une boucle

Python, comme d’autres langages, prend en charge les instructions de contrôle de boucle `break` et `continue`. Ces instructions permettent de modifier le flux d’une boucle en fonction de conditions spécifiques. Voyons comment les utiliser avec une boucle `for`.

L’instruction `break` permet de sortir immédiatement d’une boucle lorsqu’une condition est satisfaite.

Voici un exemple :

Définissons `k`, le nombre d’entrées.
Utilisons une boucle `for` pour lire les entrées de l’utilisateur, un nombre à la fois, et additionnons les nombres positifs ou nuls.
Ce processus doit continuer jusqu’à ce que l’utilisateur entre un nombre négatif.
Lorsque l’utilisateur entre un nombre négatif, quittons la boucle et affichons la somme.

k = 5
somme = 0
for i in range(k):
  num = int(input("nEntrez un nombre : "))
  if num < 0:
    break # Quitte la boucle quand num < 0
  somme += num

print(somme)

Si l’utilisateur entre un nombre négatif, le contrôle sort de la boucle `for` et passe à la première instruction qui suit la boucle.

Entrez un nombre : 2

Entrez un nombre : 3

Entrez un nombre : 5

Entrez un nombre : -1
10

Utiliser l’instruction `continue` dans une boucle `for`

L’instruction `continue` permet d’ignorer certaines itérations d’une boucle, en fonction d’une condition.

Reprenons l’exemple précédent :

Lisons l’entrée de l’utilisateur et calculons la somme des nombres non négatifs.
Si l’utilisateur entre un nombre négatif, ignorons cette itération, passons à la suivante et lisons le nombre suivant.

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

print(somme)

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, qui est négatif. Cependant, cette fois, la boucle `for` continue jusqu’à ce que le nombre d’entrées spécifié soit atteint, en ignorant les entrées négatives. Au final, nous obtenons la somme de tous les nombres non négatifs parmi les `k` entrées.

Peut-on créer une boucle `for` infinie en Python ?

Dans tous les exemples que nous avons vus jusqu’à présent, nous n’avons jamais rencontré de boucle `for` infinie. Mais est-ce possible en Python ?

Considérons la fonction `double()` suivante :

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

Si vous appelez la fonction `double()` sans spécifier la valeur de `x`, la valeur par défaut 1 est utilisée.
Si vous spécifiez une valeur pour `x`, cette valeur 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 « callable-object » (un objet appelable) et une valeur « sentinelle ».

`iter(callable-object, sentinelle)` permet d’itérer jusqu’à ce que la valeur de retour de `callable-object` soit égale à `sentinelle`.

Vous comprenez maintenant comment une boucle `for` infinie pourrait apparaître ?

Si la valeur de retour de l’objet appelable n’est jamais égale à la sentinelle, alors la boucle se poursuit indéfiniment !

Utilisons la fonction `double` comme objet appelable et définissons la valeur sentinelle sur 0.

Note : Il faut indiquer le nom de la fonction `double`, et non pas l’appel de la fonction `double()`.

Puisque la valeur de retour de la fonction `double` est toujours 2 et qu’elle n’est jamais égale à 0, nous obtenons une boucle infinie !

▶️ Essayez d’exécuter le code suivant. Il s’agit d’une boucle infinie, et vous devrez forcer l’arrêt du programme.

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

Boucles `for` en Python : Exercices pratiques

#1. Utilisez une boucle `for` pour afficher tous les nombres pairs compris entre 0 et 20.

Indice : Utilisez la fonction `range()` avec le bon pas.

#2. Affichez tous les nombres pairs de 20 à 0.

Indice : Utilisez une valeur négative pour le pas dans la fonction `range()`.

#3. Créez un tableau NumPy à trois dimensions.

Indice : Utilisez les boucles `for` et des boucles `for` imbriquées, si nécessaire, pour accéder aux lignes et éléments individuels du tableau.

Conclusion

Voici un récapitulatif des points clés que vous avez explorés dans ce guide :

La syntaxe d’une boucle `for` en Python, ainsi que son usage avec les fonctions `range()` et `enumerate()`.
L’utilisation des boucles `for` pour parcourir des listes, des tableaux, des chaînes de caractères et récupérer les arguments de ligne de commande.
L’utilisation des instructions de contrôle de boucle : `break` pour sortir d’une boucle et `continue` pour ignorer certaines itérations, en fonction de conditions spécifiques à l’intérieur d’une boucle `for`.
La compréhension du concept de boucles `for` infinies en Python.

Dans un prochain article, vous découvrirez comment utiliser la méthode `split()` en Python.

0 Partages