🌋 MISSION VOLCAN · SÉANCE 1.3 Les boucles : répéter des instructions 420-SN1-RE · Programmation en sciences · Semaine 1

Compétence 0F01 : Développer des programmes informatiques en vue d'automatiser la résolution de problèmes dans un contexte scientifique.

Objectifs de la séance

• Répéter un traitement avec une boucle pour (for)
• Répéter tant qu'une condition tient avec tant que (while)
• Accumuler un résultat au fil d'une boucle

Contenus essentiels

• Instruction répétitive (boucle)
• Séquence d'instructions

Calepin Colab. Exécutez chaque bloc de code avec Maj+Entrée. Modifiez, expérimentez, recommencez : c'est en programmant qu'on apprend à programmer.

🔁 1. La boucle pour (for) avec range

La boucle for répète un bloc un nombre connu de fois. range(n) produit les entiers de 0 à n - 1.

for compteur in range(5):
    print("Itération numéro", compteur)

range(debut, fin, pas) offre plus de contrôle. Exemple : compter de 2 en 2.

for valeur in range(0, 11, 2):
    print(valeur)

🧮 2. Accumuler un résultat

Un schéma très fréquent en sciences : on initialise un accumulateur (une variable qui démarre souvent à 0), puis on l'enrichit à chaque tour de boucle. Ici, on calcule une somme et une moyenne au fil de la boucle, sans liste.

# Accumulateur : total et moyenne calculés au fil de la boucle
total = 0
nombreTours = 0
for valeur in range(10, 21, 2):     # 10, 12, 14, 16, 18, 20
    total = total + valeur
    nombreTours = nombreTours + 1

moyenne = total / nombreTours
print("Total :", total)
print("Moyenne :", moyenne)

⏳ 3. La boucle tant que (while)

La boucle while répète tant que sa condition reste vraie. Utile quand on ne sait pas d'avance combien d'itérations seront nécessaires. Attention à toujours faire évoluer la condition, sinon la boucle est infinie.

# Désintégration : on divise par 2 jusqu'à passer sous un seuil
quantite = 100.0
nombreDemiVies = 0
while quantite > 1.0:
    quantite = quantite / 2
    nombreDemiVies = nombreDemiVies + 1

print("Nombre de demi-vies :", nombreDemiVies)
print("Quantité restante :", quantite)

🧪 EXERCICES (obligatoires)

Les exercices ci-dessous sont à faire en classe (laboratoire) ou à la maison. Complétez les cellules de code marquées # A COMPLETER.

Exercice 1. Avec une boucle for et un accumulateur, calculez la somme de tous les entiers de 1 à 100.

# A COMPLETER (exercice 1)

Exercice 2. Demandez un entier n et calculez sa factorielle n! = 1 x 2 x ... x n avec une boucle (accumulateur de type produit).

# A COMPLETER (exercice 2)

Exercice 3. Avec une boucle for et un compteur, comptez combien d'entiers de 1 à 200 sont des multiples de 7 (un nombre est multiple de 7 si nombre % 7 == 0).

# A COMPLETER (exercice 3)

Exercice 4. Affichez la table des carrés des entiers de 1 à 10 (1 -> 1, 2 -> 4, ...).

# A COMPLETER (exercice 4)

Exercice 5. Une population de bactéries double chaque heure à partir de 500 individus. Avec une boucle while, trouvez après combien d'heures elle dépasse 1 000 000.

# A COMPLETER (exercice 5)

🪜 EXERCICES INTERMÉDIAIRES (facultatifs)

Des boucles un peu plus riches : tables, suites, compteurs avec condition, saisie au clavier. À faire si les exercices de base sont acquis.

Exercice 6. Demandez un nombre entier et affichez sa table de multiplication de 1 à 10 (par exemple 7 x 1 = 7, 7 x 2 = 14, ...).

# A COMPLETER (exercice 6)

Exercice 7. Affichez les 10 premiers termes de la suite de Fibonacci sans utiliser de liste : chaque terme est la somme des deux précédents (0, 1, 1, 2, 3, 5, ...). Utilisez deux variables qui avancent ensemble.

# A COMPLETER (exercice 7)

Exercice 8. Comptez le nombre d'années bissextiles entre 0 et 3000. Une année est bissextile si elle est divisible par 4, sauf les années de siècle (divisibles par 100) qui doivent l'être par 400.

# A COMPLETER (exercice 8)

Exercice 9. Demandez 3 valeurs au clavier et affichez la plus grande, en gardant au fil de la boucle la plus grande valeur vue jusqu'ici (sans utiliser max).

# A COMPLETER (exercice 9)

Exercice 10. Avec une boucle while, lisez des mesures au clavier une à une jusqu'à ce que l'utilisateur saisisse -1. Affichez ensuite le nombre de mesures lues et leur somme.

# A COMPLETER (exercice 10)

🧗 EXERCICES AVANCÉS (défis facultatifs)

Ces défis vont plus loin : saisie au clavier, algorithmes itératifs, convergence. À tenter une fois les exercices de base réussis.

Exercice 11 (décollage). Affichez un compte à rebours de 5 à 1 avec une boucle, en marquant une pause d'une seconde entre chaque nombre (import time puis time.sleep(1)), puis affichez « Décollage ! 🚀 ».

# A COMPLETER (exercice 11)
import time

Exercice 12 (méthode de Héron). Approchez la racine carrée de 2 sans math.sqrt ni ** 0.5. Partez d'une estimation, puis raffinez-la avec estimation = (estimation + nombre / estimation) / 2, en répétant tant que estimation * estimation s'écarte de nombre de plus de 0.000001. Affichez l'estimation finale et le nombre d'itérations.

# A COMPLETER (exercice 12)
nombre = 2.0
estimation = nombre

Exercice 13 (suite de Collatz). Partez d'un entier depart (par exemple 27). Tant qu'il n'est pas égal à 1 : s'il est pair, divisez-le par 2 ; s'il est impair, faites 3 * nombre + 1. Comptez le nombre d'étapes pour atteindre 1.

# A COMPLETER (exercice 13)
depart = 27

Exercice 14 (palindrome). Vérifiez si un mot saisi est un palindrome (il se lit pareil dans les deux sens, comme « radar » ou « kayak »). On vous donne l'inversion par slicing motInverse = mot[::-1]. Défi : retrouvez le résultat avec une boucle qui compare les caractères des deux extrémités.

# A COMPLETER (exercice 14)
mot = input("Mot : ")
motInverse = mot[::-1]   # inversion fournie (slicing)

Exercice 15 (l'ordinateur devine votre nombre). Pensez à un nombre entre 1 et 100, sans le dire. L'ordinateur va le deviner par dichotomie : il propose toujours le milieu de l'intervalle, et vous répondez = (c'est ça), + (mon nombre est plus grand) ou - (plus petit). Comptez en combien d'essais il y arrive (jamais plus de 7 !).

# A COMPLETER (exercice 15)
print("Pensez à un nombre entre 1 et 100.")
basse = 1
haute = 100

---

Lien avec le projet de la semaine

Le Projet 1 repose entièrement sur les boucles : c'est ainsi qu'on traite une série complète de mesures sans écrire le calcul une fois par valeur.

Pour aller plus loin (facultatif)

• Cherchez l'instruction break qui interrompt une boucle.
• Combinez une boucle et une condition pour compter les valeurs aberrantes.