Iterating with For and While Loops

Introduction aux boucles

En programmation, il existe principalement deux types de boucles pour gérer la répétition :

1. La boucle for : Utilisée lorsque vous voulez parcourir chaque élément d'une séquence (comme une liste ou une chaîne de caractères). Vous savez combien d'itérations il y aura : une pour chaque élément.
2. La boucle while : Utilisée lorsque vous voulez répéter une action tant qu'une certaine condition est vraie. Vous ne savez pas forcément à l'avance combien d'itérations seront nécessaires.

La vidéo suivante offre une excellente introduction visuelle à ces concepts.

1. La boucle for : Itérer sur des séquences

La boucle for est votre outil de prédilection pour traiter chaque élément d'un objet "itérable" (quelque chose que vous pouvez parcourir, comme une liste, un tuple, ou une chaîne de caractères).

La syntaxe est la suivante :

for variable_temporaire in sequence:



    # Ce bloc de code s'exécute pour chaque élément de la séquence.
    # La variable_temporaire prend la valeur de l'élément actuel.

Imaginez que vous ayez une liste de courses. La boucle for est l'équivalent de prendre chaque article de la liste, un par un, et de faire quelque chose avec (par exemple, le mettre dans votre panier).

La vidéo suivante décompose ce processus en détail.

Pour une référence écrite, l'article suivant est très clair et orienté vers la science des données.

Utilisation de range() pour des répétitions définies

Parfois, vous ne voulez pas itérer sur une liste existante, mais simplement répéter une action un certain nombre de fois. Pour cela, la fonction range() est extrêmement utile. Elle génère une séquence de nombres.

• range(5) génère les nombres 0, 1, 2, 3, 4.
• range(2, 5) génère 2, 3, 4.
• range(0, 10, 2) génère 0, 2, 4, 6, 8 (de 0 à 10, par pas de 2).

# Afficher "Hello" trois fois
for i in range(3):
    print(f"Répétition numéro {i+1}: Hello!")

Notez que la variable i prendra les valeurs 0, 1, puis 2. C'est un schéma très courant en programmation.

2. La boucle while : Répéter sous condition

La boucle while est différente. Elle ne parcourt pas une séquence finie ; elle continue d'exécuter un bloc de code tant qu'une condition reste vraie.

La syntaxe est :

while condition:



    # Ce bloc de code s'exécute tant que la condition est True.
    # Il est CRUCIAL de faire quelque chose ici qui finira par rendre la condition False.

Une boucle while typique a trois parties :

1. Initialisation : On définit une variable avant la boucle.
2. Condition : La boucle while vérifie cette variable.
3. Mise à jour : À l'intérieur de la boucle, on modifie la variable pour se rapprocher de la fin.

Si vous oubliez la partie "Mise à jour", vous risquez de créer une boucle infinie, un programme qui ne s'arrête jamais !

Voici un exemple de compteur simple :

# Compte à rebours de 5 à 1
compteur = 5  # 1. Initialisation

while compteur > 0:  # 2. Condition
    print(compteur)
    compteur = compteur - 1  # 3. Mise à jour (ou compteur -= 1)

print("Décollage !")

3. Contrôler le flux des boucles : break et continue

Parfois, vous devez modifier le comportement par défaut d'une boucle. Python vous donne deux outils pour cela : break et continue.

• break : Arrête la boucle immédiatement et le programme continue son exécution après la boucle. C'est une sortie d'urgence.
• continue : Arrête l'itération actuelle et passe directement à la suivante. Le reste du code de l'itération en cours n'est pas exécuté.

Voici un exemple pratique :

nombres = [1, 2, -1, 4, 5, -2]

print("Utilisation de 'continue' pour ignorer les négatifs :")
for num in nombres:
    if num < 0:
        continue  # Ignore le reste de la boucle pour cet élément et passe au suivant
    print(f"Traitement du nombre positif : {num}")

print("\nUtilisation de 'break' pour s'arrêter au premier négatif :")
for num in nombres:
    if num < 0:
        print("Nombre négatif trouvé, arrêt de la boucle.")
        break  # Sort complètement de la boucle
    print(f"Traitement du nombre : {num}")

4. Boucles imbriquées (Nested Loops)

Vous pouvez placer une boucle à l'intérieur d'une autre. C'est ce qu'on appelle une boucle imbriquée. C'est très courant en science des données pour parcourir des structures en deux dimensions comme des matrices ou des grilles de données.

Pour chaque itération de la boucle "extérieure", la boucle "intérieure" s'exécute dans son intégralité.

Exemple : générer des paires de coordonnées.

# Boucle extérieure
for x in range(3):  # x prendra les valeurs 0, 1, 2



    # Boucle intérieure
    for y in range(2):  # y prendra les valeurs 0, 1
        print(f"({x}, {y})")

La sortie sera : (0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1).

Pratique dans Jupyter

Il est temps de mettre les mains dans le code ! Ouvrez un nouveau notebook Jupyter et expérimentez avec les exemples ci-dessous. Essayez de prédire le résultat avant d'exécuter la cellule.

# Exercice 1 : Calculer la somme des prix
prix = [19.99, 25.50, 9.75, 54.00]
total = 0
for p in prix:
    total += p  # Raccourci pour total = total + p
print(f"Le total des prix est : {total:.2f}€")





# Exercice 2 : Extraire les emails valides
adresses_email = ["user1@test.com", "spam", "user2@test.com", "user3@test.com", "mauvaise_adresse"]
adresses_valides = []
for email in adresses_email:



    # Un email valide contient un '@'
    if '@' in email:
        adresses_valides.append(email)
print(f"Adresses valides : {adresses_valides}")





# Exercice 3 : Un jeu de devinettes simple
import random
nombre_secret = random.randint(1, 10)
devinette = 0

print("\nJeu de devinettes ! Devinez un nombre entre 1 et 10.")
while devinette != nombre_secret:
    devinette = int(input("Votre proposition : "))
    if devinette < nombre_secret:
        print("Trop bas !")
    elif devinette > nombre_secret:
        print("Trop haut !")

print(f"Bravo ! Le nombre était bien {nombre_secret}.")

Conclusion

Félicitations ! Vous venez d'apprendre à automatiser des tâches répétitives, une compétence au cœur de la programmation et absolument indispensable pour le machine learning.

Points clés à retenir :

• Boucle for : À utiliser pour itérer sur chaque élément d'une séquence connue (liste, chaîne, etc.). Utilisez range() pour un nombre fixe de répétitions.
• Boucle while : À utiliser pour répéter du code tant qu'une condition est vraie, surtout lorsque le nombre d'itérations n'est pas connu à l'avance. Attention aux boucles infinies !
• break : Permet de sortir immédiatement d'une boucle.
• continue : Permet de sauter l'itération actuelle et de passer à la suivante.

Maintenant que vous savez comment contrôler le flux de vos programmes avec des conditions (if) et des répétitions (for, while), nous sommes prêts pour la prochaine étape majeure : organiser votre code de manière propre et réutilisable. Dans la prochaine leçon, nous aborderons les fonctions, qui vous permettront de regrouper des blocs de code logiques pour les appeler quand vous en avez besoin.