🌋 MISSION VOLCAN · SÉANCE 1.5

Boucles et tableaux : petits algorithmes

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 simples.

Aujourd'hui on combine boucles et listes pour écrire de petits algorithmes : suivre une valeur au fil d'une boucle, construire une nouvelle liste, choisir la bonne alternative, et s'appuyer sur la bibliothèque standard de Python.

🔀 1. La variable temporaire et l'échange (swap)¶

Pour échanger deux valeurs, on ne peut pas écrire premier = second puis second = premier : la première valeur serait perdue. On garde une copie dans une variable temporaire.

In [ ]:
premier = 10
second = 25
temporaire = premier        # on met de cote la valeur de premier
premier = second
second = temporaire
print(premier, second)      # 25 10

# Raccourci propre a Python (echange simultane) :
premier, second = second, premier
print(premier, second)      # 10 25

🧮 2. Accumuler avec + ou avec *¶

Un accumulateur part d'une valeur de départ puis se met à jour à chaque tour. Pour une somme on part de 0 ; pour un produit on part de 1.

In [ ]:
nombres = [2, 5, 3]
somme = 0
produit = 1
for nombre in nombres:
    somme = somme + nombre        # accumulateur additif (depart 0)
    produit = produit * nombre    # accumulateur multiplicatif (depart 1)
print("Somme :", somme, " Produit :", produit)

📝 3. Modifier une liste existante : réécrire une case sur place¶

Avant même de penser à construire une nouvelle liste, on peut transformer la liste qu'on a déjà en réécrivant directement chacune de ses cases par son index : liste[index] = .... On parcourt alors les index (range(len(...))), pas les valeurs. Ici, une mesure négative est physiquement impossible : on la corrige sur place à 0. La liste d'origine est modifiée, aucune nouvelle liste n'est créée.

In [ ]:
mesures = [320, -5, 850, -2, 410]
for index in range(len(mesures)):
    if mesures[index] < 0:
        mesures[index] = 0      # on reecrit la case, pas de nouvelle liste
print(mesures)   # [320, 0, 850, 0, 410]

📋 4. Construire une nouvelle liste : filtrer ou inverser¶

À l'inverse, on part souvent d'une liste vide que l'on remplit au fil de la boucle, par exemple pour ne garder que certaines valeurs (filtrer) ou pour inverser l'ordre. Cette fois, la liste d'origine n'est pas touchée.

In [ ]:
mesures = [12.1, 8.0, 15.3, 9.9, 20.0]
retenues = []
for mesure in mesures:
    if mesure >= 10:
        retenues.append(mesure)  # on copie seulement les valeurs >= 10
print(retenues)

🚦 5. Choisir l'alternative : if-elif-else, match-case, et le piège des if séparés¶

Avec elif, un seul bloc est choisi, et chaque elif profite des tests précédents : après note >= 90, dans le elif note >= 80 on sait déjà que note < 90, donc la borne basse suffit. Avec deux if séparés, les deux blocs peuvent s'exécuter : c'est une source de bugs. Pour des valeurs discrètes, match/case est souvent plus lisible.

In [ ]:
note = 73
if note >= 90:
    mention = "A"
elif note >= 80:        # ici on SAIT deja que note < 90
    mention = "B"
elif note >= 70:        # et ici, que note < 80
    mention = "C"
else:
    mention = "echec"
print(mention)

📦 6. La bibliothèque standard : math, statistics, random¶

Python est livré avec une riche bibliothèque standard. On l'utilise avec import. Quelques incontournables en sciences : math, statistics, random.

In [ ]:
import math
import statistics
import random

donnees = [12.1, 12.4, 11.9, 12.0, 12.3]
print("Racine de 2 :", math.sqrt(2))
print("Pi :", math.pi)
print("Moyenne :", statistics.mean(donnees))
print("Mediane :", statistics.median(donnees))
print("Un de :", random.randint(1, 6))
🧪 EXERCICES (obligatoires)

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

Exercice 1. À partir de masses = [1.2, 3.4, 2.1, 5.0, 4.3], calculez la masse totale avec une boucle et un accumulateur additif (sans utiliser sum).

In [ ]:
# A COMPLETER (exercice 1)
masses = [1.2, 3.4, 2.1, 5.0, 4.3]

Exercice 2. Un échantillon de 500 cellules double chaque heure. Combien y en a-t-il après 8 heures ? Utilisez un accumulateur multiplicatif : partez de la population de départ et multipliez par 2 à chaque tour de boucle. Interdit : l'opérateur ** et la fonction pow (tout l'intérêt est d'utiliser la boucle).

In [ ]:
# A COMPLETER (exercice 2)
population = 500
heures = 8

Exercice 3. Le capteur du volcan a une plage valide [0, 1000]. À partir de mesures = [320, -5, 1200, 0, 850, -2], parcourez la liste avec son index et bornez chaque valeur sur place : toute valeur négative (impossible) devient 0, toute valeur supérieure à 1000 (saturation) devient 1000. On réécrit la case avec mesures[index] = ... ; on ne crée pas de nouvelle liste.

In [ ]:
# A COMPLETER (exercice 3)
mesures = [320, -5, 1200, 0, 850, -2]

Exercice 4. À partir de mesures = [12.1, 8.0, 15.3, 9.9, 20.0], construisez une nouvelle liste bonnes contenant seulement les valeurs strictement supérieures à 10 (copier dans une nouvelle liste seulement les « super valeurs »).

In [ ]:
# A COMPLETER (exercice 4)
mesures = [12.1, 8.0, 15.3, 9.9, 20.0]

Exercice 5. À partir de temperatures = [18.2, 25.1, 19.5, 23.4], trouvez l'index de la valeur maximale en gardant l'index du meilleur au fil de la boucle (pas seulement la valeur), puis retirez cette valeur de la liste à l'aide de son index (del). Affichez l'index trouvé et la liste après retrait.

In [ ]:
# A COMPLETER (exercice 5)
temperatures = [18.2, 25.1, 19.5, 23.4]
🧗 EXERCICES INTERMÉDIAIRES (facultatifs)

Une fois les 5 obligatoires réussis, ces exercices consolident les mêmes idées avec un petit pas de plus. Ils restent facultatifs.

Exercice 6. Le capteur est mal étalonné : il lit toujours 2.5 de trop. À partir de mesures = [14.5, 22.5, 9.0, 18.2], corrigez chaque mesure sur place en lui soustrayant 2.5 (mesures[index] = mesures[index] - 2.5). Ici aucune condition : on réécrit toutes les cases. Résultat attendu : [12.0, 20.0, 6.5, 15.7].

In [ ]:
# A COMPLETER (exercice 6)
mesures = [14.5, 22.5, 9.0, 18.2]

Exercice 7. À partir de donnees = [3, 8, 1, 6, 9], construisez une nouvelle liste contenant les mêmes valeurs dans l'ordre inverse, avec une boucle (sans utiliser reverse ni le slicing [::-1]).

In [ ]:
# A COMPLETER (exercice 7)
donnees = [3, 8, 1, 6, 9]

Exercice 8. On a une mention parmi "A", "B", "C". Affichez un message (A->Excellent, B->Très bien, C->Passable, sinon À revoir) d'abord avec match/case, puis avec if/elif/else. Comparez : pour des valeurs discrètes, lequel est le plus lisible ?

In [ ]:
# A COMPLETER (exercice 8)
mention = "B"

Exercice 9. Le code ci-dessous classe un nombre avec deux if séparés et contient un bug (la deuxième catégorie écrase la première). Reproduisez le bug, expliquez-le en commentaire, puis corrigez avec elif.

if nombre > 5:
    categorie = "grand"
if nombre > 0:
    categorie = "positif"
In [ ]:
# A COMPLETER (exercice 9)
nombre = 7
🪜 EXERCICES PLUS DIFFICILES (facultatifs)

Ces exercices vont encore plus loin et sont facultatifs : à tenter une fois les obligatoires et les intermédiaires réussis.

Exercice 10. Calculez base ** exposant (par exemple 2 puissance 10) par multiplication répétée dans une boucle, en partant d'un accumulateur à 1. Interdit : l'opérateur ** et les fonctions pow() / math.pow() - tout l'intérêt est de les reconstruire à la main.

In [ ]:
# A COMPLETER (exercice 10)
base = 2
exposant = 10

Exercice 11. Même capteur (plage valide [0, 1000]) qu'à l'exercice 3, mais cette fois on jette les mesures hors plage au lieu de les borner. À partir de mesures = [320, -5, 1200, 0, 850, -2], retirez toute valeur négative ou supérieure à 1000 en parcourant les index en sens inverse (del mesures[index]) - le sens inverse évite de décaler les index restants. Résultat attendu : [320, 0, 850].

In [ ]:
# A COMPLETER (exercice 11)
mesures = [320, -5, 1200, 0, 850, -2]

Exercice 12. (a) Échangez le contenu de deux variables premier et second à l'aide d'une variable temporaire. (b) Puis décalez d'un cran vers la droite toutes les valeurs de valeurs = [1, 2, 3, 4, 5] (rotation) : le dernier élément doit revenir en première position, en traînant une variable temporaire. Résultat attendu : [5, 1, 2, 3, 4].

In [ ]:
# A COMPLETER (exercice 12)
valeurs = [1, 2, 3, 4, 5]

Exercice 13. Classez une temperature saisie en quatre catégories avec if/elif/else : gel (< 0), froid (0 à 14), doux (15 à 24), chaud (>= 25). Profitez de elif : dans chaque elif, la borne basse est déjà acquise, donc une seule comparaison suffit (distinguez bien < de sa complémentaire >=).

In [ ]:
# A COMPLETER (exercice 13)

Exercice 14. Avec la bibliothèque standard et mesures = [12.1, 12.4, 11.9, 12.0, 12.3] : affichez la moyenne et la médiane (statistics), l'hypoténuse d'un triangle 3-4 avec math.hypot, et une liste de 5 lancers de dé avec random.randint (dans une boucle).

In [ ]:
# A COMPLETER (exercice 14)
mesures = [12.1, 12.4, 11.9, 12.0, 12.3]

Lien avec le projet de la semaine¶

Le Projet 1 traite une série complète de mesures : accumuler une somme, chercher un extremum, filtrer les valeurs aberrantes dans une nouvelle liste, c'est exactement ce qu'on vient de pratiquer.

Pour aller plus loin (facultatif)¶

  • Cherchez enumerate pour parcourir indices et valeurs en mĂŞme temps.
  • La comprĂ©hension de liste [v for v in mesures if v > 10] fait le filtre en une ligne.