🔄 Boucles

Introduction aux boucles

La boucle apporte à la programmation une puissance considérable.
Elle permet de répéter des actions, de parcourir des listes, de traiter des données de manière efficace.
Elle est un des piliers de la programmation avec les conditions et les fonctions.

En gros, sa structure est la suivante :

Tant que (une certaine condition est vraie) :
    # instructions à répéter
    # instructions à répéter
    # instructions à répéter

Si on exécutait ce pseudo-code, on répéterait l'exécution des lignes 2 à 4 tant que la condition de la ligne 1 est vraie.
Dès que la condition devient fausse, on sort de la boucle et on continue l'exécution du programme à la ligne 5.

En Python, on utilise le mot-clé while pour créer une boucle de ce type.
Voici un exemple simple :

compteur = 0
while compteur < 5:
    print("Compteur =", compteur)
    compteur = compteur + 1  # Incrémente le compteur de 1
print("Fin de la boucle")

Dans cet exemple, la boucle while continue tant que la variable compteur est inférieure à 5, c'est-à-dire tant que l'expression compteur < 5 est évaluée à True.
À chaque itération (tour de la boucle), elle affiche la valeur du compteur (ligne 3) et l'incrémente de 1 (ligne 4).
Quand compteur atteint 5, la condition (compteur < 5) devient fausse (False) et la boucle se termine.

Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrêt sur la ligne 1 et avancez une ligne à la fois pour suivre l'évolution de la variable compteur.

Attention aux boucles infinies

Il est crucial de s'assurer que la condition de la boucle deviendra fausse à un moment donné.
Sinon, la boucle continuera indéfiniment, ce qui peut faire planter votre programme.
Dans l'exemple ci-dessus, si on oublie d'incrémenter compteur, la condition compteur < 5 restera toujours vraie et la boucle ne s'arrêtera jamais.

affectation raccourcie

Pour incrémenter une variable, on peut utiliser l'opérateur d'affectation raccourcie +=.
Par exemple, au lieu d'écrire compteur = compteur + 1, on peut écrire compteur += 1.
Cela fonctionne de la même manière pour les autres opérations mathématiques avec les opérateurs -=, *=, /=, etc.

Voici le même exemple avec l'opérateur += :

compteur = 0
while compteur < 5:
    print("Compteur =", compteur)
    compteur += 1  # Incrémente le compteur de 1
print("Fin de la boucle")

Autre exemple

Voici un autre exemple qui utilise une boucle while pour calculer la somme des nombres de 1 à 10 :

somme = 0
nombre = 1
while nombre <= 10:
    somme += nombre  # Ajoute le nombre courant à la somme
    nombre += 1      # Passe au nombre suivant
print("La somme des nombres de 1 à 10 est :", somme)

Dans cet exemple, la boucle continue tant que nombre est inférieur ou égal à 10 (nombre <= 10).
À chaque itération, elle ajoute la valeur de nombre à somme et incrémente nombre de 1.
Quand nombre devient 11, la condition nombre <= 10 devient fausse et la boucle se termine.
Le programme affiche alors la somme totale des nombres de 1 à 10.

Exécutez-le en mode débogage pour suivre l'évolution des variables somme et nombre à chaque itération!

Les explications de cette section étaient-elles claires ?

Opérateurs d'affectation

Nous avons déjà vu l'opérateur d'affectation = qui permet d'affecter une valeur à une variable.
Par exemple :

x = 5
y = 10

Python propose également des opérateurs d'affectation composés qui permettent de faire des opérations mathématiques et de réaffecter le résultat à la même variable en une seule instruction.

Voici les opérateurs d'affectation composés les plus courants :

Opérateur	Description	Exemple	Équivalent à
+=	Addition et affectation	a += b	a = a + b
-=	Soustraction et affectation	a -= b	a = a - b
*=	Multiplication et affectation	a *= b	a = a * b
/=	Division et affectation	a /= b	a = a / b
%=	Modulo et affectation	a %= b	a = a % b
//=	Division entière et affectation	a //= b	a = a // b
**=	Exponentiation et affectation	a **= b	a = a ** b

Ces opérateurs sont très utiles pour simplifier le code et rendre les opérations plus concises.

Exemple d'utilisation

compteur = 0
compteur += 1  # équivalent à compteur = compteur + 1
compteur *= 2  # équivalent à compteur = compteur * 2
print(compteur)  # Affiche 2

Les explications de cette section étaient-elles claires ?

La fonction range()

range() génère une séquence de nombres. Il existe 3 façons de l'appeler selon le nombre de paramètres :

range(stop) : part de 0, avance de 1 en 1, s'arrête avant stop
range(start, stop) : part de start, avance de 1 en 1, s'arrête avant stop
range(start, stop, step) : part de start, avance de step en step, s'arrête avant stop

Appel	Produit les nombres
range(5)	0, 1, 2, 3, 4
range(1, 5)	1, 2, 3, 4
range(0, 11, 2)	0, 2, 4, 6, 8, 10
range(5, 0, -1)	5, 4, 3, 2, 1

⚠️ range() n'est pas exactement une liste en Python, mais elle se comporte de la même façon lorsqu'on la parcourt.

Boucle for avec range()

La boucle for parcourt une séquence de valeurs une par une, et exécute les instructions du bloc à chaque itération (à chaque tour de boucle).

Sa structure est la suivante :

for i in range(start, stop, step):
    # instructions répétées à chaque itération

À chaque itération de boucle, i prend automatiquement la valeur suivante dans la séquence produite par range().

À noter

La boucle for est un cas particulier de while. Elle est simplement plus pratique quand on sait d'avance combien de tours on veut faire.

Voici quatre exemples, lisez d'abord le commentaire, puis le code :

# Exemple 1 : i vaut 0, puis 1, puis 2, puis 3, puis 4 → 5 tours
for i in range(5):
    print(i)

# Exemple 2 : i commence à 1 et s'arrête avant 6 → affiche 1 à 5
for i in range(1, 6):
    print(i)

# Exemple 3 : i avance de 2 en 2 → affiche seulement les pairs
for i in range(0, 11, 2):
    print(i)

# Exemple 4 : step négatif → i descend de 5 jusqu'à 1
for i in range(5, 0, -1):
    print(i)

👉 Exécutez ces exemples en mode débogage, un à la fois.
Mettez un point d'arrêt sur le for et avancez ligne par ligne pour voir i changer de valeur à chaque itération.

Parcourir une liste avec for, range() et len()

Puisque range() produit une séquence d'index (0, 1, 2…), on peut l'utiliser pour accéder à chaque élément d'une liste tour par itération.

len(liste) retourne le nombre d'éléments d'une liste. Donc range(len(liste)) génère exactement les bons index pour parcourir toute la liste :

consoles = ["PS5", "Xbox Series X", "Nintendo Switch 2"]
nb_elements = len(consoles)       # nb_elements vaut 3
for i in range(nb_elements):      # i prendra les valeurs 0, 1, 2
    print(consoles[i])            # accède à l'élément à la position i

# On aurait pu écrire directement :
# for i in range(len(consoles)):

Au 1er tour : i vaut 0 → consoles[0] → "PS5"
Au 2e tour : i vaut 1 → consoles[1] → "Xbox Series X"
Au 3e tour : i vaut 2 → consoles[2] → "Nintendo Switch 2"

👉 Exécutez ce code en mode débogage et observez i et consoles[i] évoluer ensemble à chaque itération.

Quand on n'a pas besoin de i : utiliser _

Parfois, on veut simplement répéter une action un certain nombre de fois, sans jamais utiliser la valeur de i à l'intérieur de la boucle.

Par exemple, afficher 5 fois le même message :

for i in range(5):
    print("Bienvenue!")  # i n'est pas utilisé

Dans ce cas, nommer la variable i est trompeur : ça laisse croire qu'on va s'en servir, alors qu'on ne l'utilise pas.
La convention en Python est d'utiliser _ (un tiret bas) pour signaler explicitement que la variable est intentionnellement ignorée :

for _ in range(5):
    print("Bienvenue!")  # on répète 5 fois, la valeur du tour ne nous intéresse pas

Le résultat est identique, mais _ communique clairement l'intention : "je n'ai pas besoin de savoir à quel tour je suis, je veux juste répéter."

👉 Règle simple : si on utilise la variable de boucle dans le bloc (consoles[i], i * 2, etc.), on la nomme i. Si on ne l'utilise jamais, on utilise _.

for ou while? Savoir choisir

La règle est simple : for quand on connaît le nombre de tours d'avance, while quand on ne le connaît pas.

On utilise un for quand le nombre d'itérations est connu ou calculable avant d'entrer dans la boucle :

Afficher les 12 mois de l'année → on sait qu'il y en a exactement 12.
Parcourir une liste de 30 étudiants → len(liste) nous donne le compte d'avance.
Calculer la table de multiplication de 7 (de 1 à 10) → exactement 10 tours.
Répéter une action 5 fois → le nombre est fixé d'avance.

On n'a pas le choix d'utiliser un while quand le nombre d'itérations dépend de quelque chose qui survient pendant l'exécution, donc impossible à connaître d'avance :

Redemander un mot de passe tant qu'il est incorrect → l'utilisateur pourrait le réussir au 1er essai... ou au 50e. Impossible à prévoir.
Générer des nombres aléatoires jusqu'à tomber sur un 6 → ça pourrait arriver tout de suite ou prendre des dizaines de tours.
Continuer une partie tant que le joueur n'a pas perdu → on ne sait pas combien de tours durera la partie.
Lire des données tant qu'il en reste à lire → le nombre dépend du contenu du fichier.

👉 Le test mental : « Est-ce que je peux écrire le nombre de tours sur un papier AVANT de lancer la boucle? » Si oui → for. Si non → while.

Les explications de cette section étaient-elles claires ?

Structures combinées

Il est possible de combiner les différentes structures de contrôle pour créer des programmes plus complexes et puissants.
Par exemple, on peut imbriquer des boucles à l'intérieur d'autres boucles, ou utiliser des conditions à l'intérieur de boucles.

Voici un exemple simple qui combine une boucle for avec une condition if pour afficher les nombres pairs de 0 à 10 :

for i in range(11):
    if i % 2 == 0:
        print(i)

Dans cet exemple, la boucle for itère sur les nombres de 0 à 10, et la condition if vérifie si le nombre est pair (c'est-à-dire si le reste de la division par 2 est égal à 0).
Si la condition est vraie, le nombre est affiché.

Exemple avec une liste

On peut combiner for et if pour traiter les éléments d'une liste selon une condition.
Voici un exemple qui parcourt une liste de températures et affiche un message différent selon que la température indique une fièvre ou non :

temperatures = [36.5, 38.2, 37.1, 39.8, 36.9]
for i in range(len(temperatures)):
    if temperatures[i] > 37.5:
        print(f"{temperatures[i]}°C : fièvre!")
    else:
        print(f"{temperatures[i]}°C : normale")

À chaque itération, i prend la valeur de l'index courant et temperatures[i] accède à la température correspondante dans la liste.
La condition if détermine ensuite quel message afficher pour cette température.

Exécutez ce code en mode débogage pour suivre l'évolution de i et de temperatures[i] à chaque itération.

Les explications de cette section étaient-elles claires ?

Instructions break, continue et pass

Parfois, on peut vouloir interrompre une boucle avant qu'elle ne se termine naturellement, ou sauter certaines itérations.
Python fournit trois instructions spéciales pour gérer ces situations : break, continue et pass.

break

Cette instruction permet de sortir immédiatement d'une boucle, qu'elle soit for ou while.
Lorsqu'un break est rencontré, l'exécution du programme continue à la ligne suivant la boucle.

for i in range(10):
    if i == 5:
        break  # Sort de la boucle lorsque i vaut 5
    print(i)
print("Fin de la boucle")

Dans cet exemple, la boucle s'arrête dès que i atteint 5.

continue

Cette instruction permet de sauter le reste du code dans la boucle pour l'itération en cours et de passer directement à l'itération suivante.

for i in range(10):
    if i % 2 == 0:
        continue  # Saute les nombres pairs
    print(i)

Ici, seuls les nombres impairs sont affichés, car les nombres pairs sont ignorés grâce à continue.

pass

Cette instruction est un "no-op" (no operation), c'est-à-dire qu'elle ne fait rien.
Elle est souvent utilisée comme un espace réservé dans des blocs de code où une instruction est requise syntaxiquement mais où aucune action n'est nécessaire.

for i in range(5):
    if i < 3:
        pass  # Ne fait rien pour i < 3
    else:
        print(i)

Dans cet exemple, rien ne se passe pour les valeurs de i inférieures à 3, mais pour les autres valeurs, elles sont affichées.

Pour bien comprendre

Exécutez ces exemples en mode débogage pour bien comprendre comment chaque instruction affecte le flux d'exécution de la boucle.
Mettez des points d'arrêt aux endroits stratégiques et avancez ligne par ligne pour observer le comportement du programme.

Les explications de cette section étaient-elles claires ?

Éviter la répétition : les boucles et les listes

En programmation, on suit souvent le principe DRY (Don't Repeat Yourself).
Si vous remarquez que vous copiez-collez un bloc d'instructions en changeant seulement quelques valeurs, c'est le signe qu'il faut utiliser une boucle!

⚠️ Le code redondant

Voici un programme qui affiche les informations de trois étudiants. Le bloc d'instructions est répété trois fois, seules les valeurs changent :

print("Étudiant #1")
print("Nom : Félix")
print("Note : 72")
print()

print("Étudiant #2")
print("Nom : Dayron")
print("Note : 91")
print()

print("Étudiant #3")
print("Nom : Léa")
print("Note : 58")
print()

Ce code fonctionne, mais il est difficile à maintenir : ajouter un 4e étudiant oblige à copier-coller un nouveau bloc. Et si le format d'affichage change, il faut modifier trois endroits!

Étape 1 : Identifier ce qui change

En observant les trois blocs, on remarque que seules trois choses varient d'un bloc à l'autre :

Le numéro de l'étudiant (#1, #2, #3)
Le nom (Félix, Dayron, Léa)
La note (72, 91, 58)

Le numéro correspond simplement à la position dans la liste (index 0, 1, 2), donc on peut le calculer automatiquement avec i + 1.
On regroupe les noms et les notes dans des listes parallèles :

noms  = ["Félix", "Dayron", "Léa"]
notes = [72, 91, 58]

✅ Étape 2 : Remplacer la répétition par une boucle

Maintenant qu'on a les données dans des listes, une seule boucle suffit pour traiter tous les étudiants :

noms  = ["Félix", "Dayron", "Léa"]
notes = [72, 91, 58]

nb_elements = len(noms)
for i in range(nb_elements):
    print(f"Étudiant #{i + 1}")
    print(f"Nom : {noms[i]}")
    print(f"Note : {notes[i]}")
    print()

Le résultat affiché est identique à la version redondante, mais le code est bien plus court et plus facile à maintenir.

L'avantage clé : la flexibilité

Pour ajouter un 4e étudiant, on n'ajoute qu'un élément dans chaque liste et la boucle s'adapte automatiquement grâce à len() :

noms  = ["Félix", "Dayron", "Léa", "Tristan"]
notes = [72, 91, 58, 83]

nb_elements = len(noms)
for i in range(nb_elements):
    print(f"Étudiant #{i + 1}")
    print(f"Nom : {noms[i]}")
    print(f"Note : {notes[i]}")
    print()

👉 Le corps de la boucle n'a pas changé d'une seule ligne. C'est la puissance de combiner les listes et les boucles!

Les explications de cette section étaient-elles claires ?

Boucles imbriquées

Il est possible de placer une boucle à l'intérieur d'une autre boucle.
On parle alors de boucles imbriquées.

Voici un exemple simple avec deux boucles for imbriquées pour afficher une table de multiplication :

for i in range(1, 6):           # Boucle extérieure pour les lignes
    for j in range(1, 6):       # Boucle intérieure pour les colonnes
        print(i * j, end='\t')  # Affiche le produit avec une tabulation
    print()                     # Nouvelle ligne après chaque ligne de la table

Dans cet exemple, la boucle extérieure itère sur les valeurs de i de 1 à 5, et pour chaque valeur de i, la boucle intérieure itère sur les valeurs de j de 1 à 5.
Le produit i * j est affiché dans une grille formatée.

Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrêt sur la ligne 1 et avancez une ligne à la fois pour suivre l'évolution des variables i et j.

Exemple avec une boucle while

Voici un exemple similaire utilisant des boucles while imbriquées pour afficher un triangle d'étoiles :

lignes = 5
i = 1
while i <= lignes:           # Boucle extérieure pour les lignes
    j = 1
    while j <= i:            # Boucle intérieure pour les étoiles dans chaque ligne
        print('*', end=' ')  # Afficher une étoile sans générer un saut de ligne
        j += 1
    print()                  # Nouvelle ligne après chaque ligne d'étoiles
    i += 1

Dans cet exemple, la boucle extérieure contrôle le nombre de lignes, tandis que la boucle intérieure contrôle le nombre d'étoiles affichées dans chaque ligne.

Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrêt sur la ligne 2 et avancez une ligne à la fois pour suivre l'évolution des variables i et j.

Exemple

Voici une fonction qui prend comme paramètres une largeur et une hauteur, et qui affiche un rectangle de # de ces dimensions :

def afficher_rectangle(largeur, hauteur):
    for i in range(hauteur):          # Boucle pour chaque ligne
        for j in range(largeur):      # Boucle pour chaque colonne
            print('#', end='')        # Affiche un '#' sans saut de ligne
        print()                       # Nouvelle ligne après chaque ligne de '#'
afficher_rectangle(5, 3)

Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Il devrait afficher :

#####
#####
#####

Voici maintenant une version qui utilise la concaténation de chaînes de caractères (str) pour construire chaque ligne avant de l'afficher :

def afficher_rectangle(largeur, hauteur):
    for i in range(hauteur):          # Boucle pour chaque ligne
        ligne = ''                    # Initialise une chaîne vide pour la ligne
        for j in range(largeur):      # Boucle pour chaque colonne
            ligne += '#'              # Concatène un '#' à la chaîne de la ligne
        print(ligne)                  # Affiche la ligne complète
afficher_rectangle(5, 3)

Vous remarquerez que le résultat est le même, mais la méthode est différente.
Entre autres, cela évite d'utiliser print() à chaque itération de la boucle intérieure, ce qui peut être plus efficace pour de grandes dimensions.

Exécutez ce code en mode débogage pour bien voir la str ligne s'allonger à chaque itération de la boucle intérieure.

Les explications de cette section étaient-elles claires ?

La fonction `input()`

La fonction input() permet de demander à l'utilisateur de saisir une entrée.
Elle peut être utilisée avec ou sans paramètre.

Sans paramètre, elle attend une saisie de l'utilisateur.
Avec un paramètre, elle affiche un message pour guider l'utilisateur.

Par exemple (essayez ce code dans un script Python) :

# Exemple sans paramètre
saisie_utilisateur = input()  # attend une saisie de l’utilisateur
print(saisie_utilisateur)

# Exemple avec un paramètre
prenom = input("Veuillez saisir votre prénom : ")
print(prenom)

La fonction input met le programme sur pause!

Lorsque la fonction input(...) est exécutée, le programme se met en pause.
Le programme attend que l’utilisateur.rice écrive quelque chose dans la console et qu’il ou elle appuie sur la touche ENTRÉE.
C’est donc normal que l’instruction suivante ne soit pas exécutée tant que vous n’avez pas saisi quelque chose dans la console!

La fonction input(...) retourne TOUJOURS une chaîne de caractères (str), même si l’utilisateur saisit un nombre.
Pour utiliser la valeur dans un calcul, il faut la convertir avec int() ou float().

Voici deux exemples concrets :

Demander un nombre entier ou décimal

# Demander un nombre entier (int)
age = int(input("Entrez votre âge : "))
print(f"Dans 10 ans, vous aurez {age + 10} ans.")

# Demander un nombre décimal (float)
taille = float(input("Entrez votre taille en mètres : "))
print(f"Votre taille en centimètres est {taille * 100} cm.")

int() convertit la chaîne en nombre entier et float() en nombre décimal.
Sans cette conversion, Python traiterait la saisie comme du texte et l’addition ou la multiplication ne fonctionnerait pas comme prévu.

Les explications de cette section étaient-elles claires ?

🕵️‍♂️ Trace d’exécution avec des structures répétitives

Voici un exemple de trace d'exécution contenant des structures répétitives

Certaines lignes s'exécutent plusieurs fois, c'est le principe de la boucle!
On indique les lignes qui testent une condition (while et for).

Code

Si on a le code suivant :

i = 0
while i < 2:
    print(f'i vaut {i}')
    i = i + 1
print("fin")

Trace

On aura la trace suivante :

	portée globale
#ligne	i	affichage	pile d'appels	fonction appelée	valeur retournée
1	0
2	0
3	0	i vaut 0
4	1
2	1
3	1	i vaut 1
4	2
2	2
5	2

Code

Si on a le code suivant :

for j in range(2):
    print(f'j vaut {j}')
print("fin")

Trace

On aura la trace suivante :

	portée globale
#ligne	j	affichage	pile d'appels	fonction appelée	valeur retournée
1	0
2	0	j vaut 0
1	1
2	1	j vaut 1
1	1
3	1

Le modèle de la classe inversée : maximiser votre apprentissage!

Pour favoriser une progression efficace, ce cours adopte une approche de classe inversée. Ce modèle déplace l'acquisition théorique hors de la classe pour transformer les heures de rencontre en véritables séances d'application pratique.

À la maison (Exploration et Appropriation) : Vous êtes le maître de votre rythme. Ces activités vous permettent de découvrir les nouveaux concepts et tester les exemples au moment où vous êtes le plus concentré. Si une notion vous semble obscure, n'hésitez pas à poser des questions à votre prof au fur et à mesure.
En classe (Application et Consolidation) : Le temps en présentiel est une ressource précieuse. Nous l'utilisons pour nous attaquer aux défis plus complexes et aux exercices de programmation qui demandent une mobilisation active de vos connaissances. C’est le moment idéal pour obtenir une rétroaction immédiate, collaborer avec vos pairs et bénéficier de l'accompagnement de votre enseignant au moment où vous en avez le plus besoin.

🏠 Activités à faire à la maison
🏫 Activités à faire en classe

🧠 Auto-validation des connaissances

Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R05. Ne faites ce questionnaire que lorsque vous vous sentez en très bonne maîtrise de la matière. En classe, dès votre arrivée, vous aurez un questionnaire très similaire, évalué sommativement, à compléter sans accès à aucune documentation.

attention

Ne pas remplir le formulaire diminue fortement vos chances de réussir l’évaluation sommative en début de rencontre.
Assurez-vous de bien comprendre toutes les notions derrière chaque question.

✏️ Exercices de compréhension

Exercice - Révision : Trace avec fonction

🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.

En situation d'examen, vous devrez compléter une trace d'exécution sur papier sans utiliser d'ordinateur.

Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.\
En suivant la recette de trace avec fonctions, complétez le tableau de trace d'exécution ligne par ligne.

def double(x, y, z):
    b = 9
    return x * y + z - x

a = 5
b = 6
z = 7
a = double(z, b, a)

Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.

Notions visées

Appel de fonction, paramètres et ordre des arguments, return, portée des variables (variable locale b), trace d'exécution, débogueur

Exercice - Trace while

🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.

Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant la recette de trace avec boucle, complétez le tableau de trace d'exécution ligne par ligne.

mystere = 1
while mystere < 4 :
    mystere += mystere
    print(mystere)
print("FIN DU PROGRAMME")

Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.

Notions visées

Boucle while, condition d'arrêt, opérateur +=, trace d'exécution, débogueur

Exercice - Trace while, if, break

🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.

Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant les recettes de trace avec boucle et avec condition, complétez le tableau de trace d'exécution ligne par ligne.

compteur = 1
nombre = 1
while compteur < 3:
    nombre = nombre + compteur
    if compteur % 2 == 0:
        break
    compteur += 1
print(f"compteur = {compteur} nombre = {nombre}")

Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.

Notions visées

Boucle while, condition d'arrêt, structure conditionnelle (if), break, opérateur modulo (%), opérateur +=, variables accumulatrices, f-string, trace d'exécution, débogueur

Exercice - Trace range imbriqué, if, continue

🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.

for i in range(1, 3):
    if i == 2:
        continue
    for j in range(4, 6):
        print(i + j)

Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.

Notions visées

Boucles for imbriquées, range(), structure conditionnelle (if), continue, ordre d'exécution, trace d'exécution, débogueur

🎯 Solutionnaires

attention

Consultez le solutionnaire uniquement après avoir complété l'exercice par vous-même.
Comparer votre réponse avec une solution vous permet de valider votre raisonnement et de corriger vos erreurs.
Consulter la solution avant d'avoir tenté l'exercice prive votre cerveau de l'occasion de construire des connexions durables.

Révision : Trace avec fonction — solutionnaire.pdf
Trace while — solutionnaire.pdf
Trace while, if, break — solutionnaire.pdf
Trace range imbriqué, if, continue — solutionnaire.pdf

✏️ Exercices de compréhension

Documentation autorisée

Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.

Exercice - Débogue et compte

📁 Créez un fichier r05_debogue_compte.md pour votre réponse.

En exécutant ce code en mode débogage, déterminez :

combien de fois la ligne 4 est exécutée,
les valeurs successives de resultat.

def factorielle(n):
    resultat = 1
    for i in range(1, n + 1):
        resultat *= i
    return resultat

r = factorielle(9)
print(r)

Notions visées

Boucle for avec range(), débogueur (compter les itérations, observer une variable), return

Exercice - Evalue une expression

📁 Créez un fichier r05_evalue_expression.md pour votre réponse.

Exécutez ce code en mode débogage et, en suivant cette recette, utilisez la fonctionnalité "Evaluate Expression" pour calculer les expressions suivantes lorsque l'exécution est arrêtée à la ligne 5 (mettez un point d'arrêt!) :

compteur * 2
compteur > 3
compteur % 2 == 0
compteur + 100

total = 0
compteur = 0
for i in range(1, 6): # i → va valoir 1, 2, 3, 4 puis 5
    total += i
    compteur += 1
print(total)
print(compteur)

Une fois la boucle terminée, que représente concrètement la valeur affichée aux lignes 6 et 7?

remarque

total et compteur sont des variables accumulatrices : elles ne reçoivent pas une valeur fixe dès le départ, mais s'enrichissent à chaque passage dans la boucle. On les reconnaît à leur initialisation à 0 avant la boucle et à l'opérateur += qui accumule les valeurs au fil des itérations.

Notions visées

Débogueur (« Evaluate Expression », point d'arrêt), boucle for, opérateurs arithmétiques et logiques, modulo

🔨 Exercices de création

Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.

Documentation autorisée

Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.

Exercice - Afficher 5 chiffres aléatoires

📁 Créez un fichier r05_aleatoire.py pour votre réponse.

Afficher 5 chiffres aléatoires les uns en dessous des autres.

Les chiffres doivent être compris dans l'ensemble 1, 2, 3, 4, 5.
Un même chiffre peut être affiché plusieurs fois.

Notions visées

Boucle (for), module random

Exercice - Générateur jusqu'à la cible 🎯

📁 Créez un fichier r05_cible.py pour votre réponse.

Écrivez un programme qui génère des nombres entiers aléatoires entre 1 et 10 à l'infini, et qui s'arrête dès qu'il génère un multiple de 7.

À chaque tour, le programme affiche le nombre généré.
Quand la condition d'arrêt est atteinte, il affiche un message de fin indiquant combien de nombres ont été générés au total.

✅ Exemple de sortie (les valeurs changent à chaque exécution)

3
9
2
7
Arrêt après 4 nombres générés.

astuce

La boucle while est idéale ici : on ne sait pas à l'avance combien de tours seront nécessaires.
Pour compter les tours, utilisez une variable accumulatrice.

🎯 Pour aller plus loin

Modifiez le programme pour qu'il s'arrête plutôt dès que le même nombre est généré deux fois de suite.
(Indice : il faut mémoriser le nombre du tour précédent.)

Notions visées

Boucle while avec condition d'arrêt non triviale, module random, variable accumulatrice (compteur de tours), opérateur modulo (%)

Exercice - Jeu de devinette numérique

📁 Créez un fichier r05_devine.py pour votre réponse.

Écrivez un programme qui choisit un nombre entier aléatoire entre 0 et 100.
L'utilisateur doit deviner ce nombre.

Tant que la réponse est incorrecte, le programme indique si le nombre à deviner est plus haut ou plus bas.
Lorsqu'il trouve le bon nombre, le programme le félicite.

Exemple de messages :
→ "Plus haut!"
→ "Plus bas!"
→ "Bravo humain, vous avez trouvé le nombre!"

astuce

Pour ce numéro, vous devez utiliser la fonction input() et int().
Il est possible d'utiliser ces fonctions à l'intérieur d'une boucle!

La fonction input met le programme sur pause!

Lorsque la fonction input(...) est exécutée, le programme se met en pause.
Le programme attend que l'utilisateur.rice écrive quelque chose dans la console et qu'il ou elle appuie sur la touche ENTRÉE.
C'est donc normal que l'instruction suivante ne soit pas exécutée tant que vous n'avez pas saisi quelque chose dans la console!

Notions visées

Boucle while, module random, input(), int(), structures conditionnelles, condition d'arrêt

Exercice - Remplir et analyser une liste 🎲

📁 Créez un fichier r05_liste_aleatoire_boucle.py pour votre réponse.

À la Rencontre #2, vous aviez rempli une liste avec cinq .append() copiés-collés, et un petit mot disait :
« une boucle ferait ça automatiquement… vous verrez ça bientôt! ».

Bientôt, c'est maintenant. 🚀

PARTIE 1 - Construire la liste avec une boucle

Partez d'une liste vide.
À l'aide d'une boucle, ajoutez 10 nombres entiers aléatoires (entre 1 et 100 inclusivement) à la liste.
Affichez la liste obtenue.

PARTIE 2 - Parcourir la liste par index

Parcourez la liste avec une boucle pour afficher chaque nombre sur sa propre ligne, précédé de « → ».
Dans la même logique de parcours, comptez combien de nombres sont supérieurs à 50 à l'aide d'une variable accumulatrice compteur.

astuce

Utilisez une variable accumulatrice initialisée à 0 avant la boucle. À l'intérieur, une structure conditionnelle (if) vous permettra de décider à quel moment l'incrémenter.

✅ Exemple de sortie (les valeurs changent à chaque exécution)

Liste générée : [42, 7, 91, 55, 23, 88, 3, 67, 50, 12]

→ 42
→ 7
→ 91
...
→ 12

Nombres supérieurs à 50 : 4

🎯 Pour aller plus loin

Modifiez le programme pour générer non pas 10, mais 10 000 nombres, sans rien changer d'autre que ce nombre.

Notions visées

Construction d'une liste avec .append() dans une boucle, parcours par index, accumulateur de comptage, for + if, module random, généralisation

Exercice - Umbrella Corporation, version boucle ☣️

📁 Créez un fichier r05_umbrella_boucle.py pour votre réponse.

À la Rencontre #3, vous aviez amélioré le rapport de l'Umbrella Corporation en créant une fonction afficher_echantillon(...) que vous appeliez 3 fois manuellement sur des listes parallèles. La promesse était : « avec une boucle, un seul appel suffirait pour traiter tous les échantillons ». Tenons-la! 🧟

🛠️ INSTRUCTIONS

Recopier intégralement le code fait pour l'exercice (r03_umbrella_corporation.py) dans le nouveau script r05_umbrella_boucle.py.
Ne modifiez pas la fonction afficher_echantillon(...) (vous devez l'utiliser sans la modifier).
Remplacez les 3 appels manuels à la fonction par une seule boucle appelant la fonction avec les valeurs de l'échantillon correspondant à l'index i.

Lorsqu'on exécute votre version, on doit observer exactement le même résultat que la version R3, mais avec un appel de fonction au lieu de trois.

🎯 Pour aller plus loin

Ajoutez un 4ᵉ échantillon dans les listes. Votre boucle doit l'afficher sans aucune autre modification au code. C'est ça, la puissance de combiner listes et boucles!

Notions visées

Boucle for, parcours de listes parallèles par index, réutilisation et appel d'une fonction dans une boucle, généralisation via len()

Exercice - CALCULER DES STATISTIQUES

📁 Créez un fichier r05_statistiques.py pour votre réponse.

La corporation remarque des variations de la température dans l'une des salles d'entreposage.
Différentes mesures de la température ont été prises durant la journée :

temperatures = [23.5, 25.4, 27.6, 21.9, 26.7, 24.6]

Contrainte

Vous n'avez pas le droit d'utiliser des fonctions prédéfinies comme min(), max(), sum(), len(), sort(), sorted(), ... (ಥ⌣ಥ).
Votre code doit fonctionner peu importe le nombre de mesures dans la liste.

PARTIE 1 : Compteur, somme et moyenne

À l'aide d'une boucle, calculez et affichez :

le nombre de mesures prises
la somme des températures
la température moyenne

✅ Résultat attendu :

Températures : [23.5, 25.4, 27.6, 21.9, 26.7, 24.6]
 nb. mesures : 6
       somme : 149.7
     moyenne : 24.95

Astuces

Compteur : utilisez une variable accumulatrice, comme vu précédemment, pour compter le nombre de températures.
Somme : utilisez une variable accumulatrice, comme vu précédemment, pour faire la somme des températures.
Moyenne : calculez-la après la boucle à partir des deux variables précédentes.

PARTIE 2 : Minimum et maximum

Ajoutez une deuxième boucle pour calculer et afficher la température la plus basse et la plus élevée.

✅ Résultat attendu (en plus de la Partie 1) :

         min : 21.9
         max : 27.6

Astuces

Initialisez min_temp et max_temp avec le premier élément de la liste avant de démarrer la boucle.
À chaque itération, comparez la température courante avec min_temp et max_temp, et mettez-les à jour si nécessaire.
Après la dernière itération, min_temp et max_temp contiennent les valeurs recherchées.

🎯 Pour aller plus loin

Fusionnez vos deux boucles en une seule qui calcule les 5 statistiques en même temps.

Notions visées

Boucle (for/while), parcours d'une liste, variables accumulatrices (compteur, somme), calcul de min/max sans fonction prédéfinie, structures conditionnelles, généralisation

Exercice - Énumérer des décimales 🔬

📁 Créez un fichier r05_decimales.py pour votre réponse.

À la Rencontre #2, vous avez découvert que les nombres flottants ne sont pas toujours exacts (0.1 + 0.2 donne 0.30000000000000004).
On va maintenant utiliser une boucle imbriquée pour observer ce phénomène à plus grande échelle.

Bob veut énumérer les décimales 0.1 à 0.9, puis 0.01 à 0.09, puis 0.001 à 0.009.
Il les calcule en multipliant un chiffre i (de 1 à 9) par une puissance de 10 négative :

for puissance in range(1, 4):       # puissance vaut 1, puis 2, puis 3
    for i in range(1, 10):          # i vaut 1, 2, ..., 9
        nombre = i * 10 ** -puissance
        print(nombre, end="  ")
    print()                         # saut de ligne après chaque groupe

PARTIE 1 - Observer

Exécutez ce code et observez la sortie.
Repérez les nombres qui ne s'affichent pas exactement comme prévu (par exemple 0.30000000000000004 au lieu de 0.3).

PARTIE 2 - Comparer avec `round()`

Modifiez la boucle pour afficher, à côté de chaque nombre, sa version arrondie avec round(nombre, puissance).
Pour chaque valeur, affichez aussi si les deux sont identiques ou non grâce à une condition.

✅ Exemple de sortie (extrait)

1 → round: 0.1 → identique
2 → round: 0.2 → identique
30000000000000004 → round: 0.3 → DIFFÉRENT
4 → round: 0.4 → identique

🎯 Pour aller plus loin

Augmentez la portée pour aller jusqu'à 0.000000001 en changeant une seule valeur dans votre code.
Bob a essayé une autre méthode pour générer les mêmes décimales :
au lieu de multiplier, il construit une chaîne de caractères puis la convertit en float.

Remplacez la ligne 3 (nombre = i * 10 ** -puissance) par :

nombre = float("0." + "0" * (puissance - 1) + str(i))

Reprenez votre comparaison de la Partie 2 avec cette méthode. Que remarquez-vous? Y a-t-il encore des nombres marqués « DIFFÉRENT »?

💡 Cela illustre une idée importante : la précision dépend de la façon dont on calcule une valeur, pas seulement de la valeur elle-même.

Notions visées

Boucles imbriquées (for), range(), opérateur de puissance (**), précision des flottants, round(), structure conditionnelle, end dans print(), conversion str → float

Exercice - Générer un nombre - DRY : boucle simple

📁 Créez un fichier r05_generer_nombre.py pour votre réponse.

Le code de la fonction ci-dessous permet de générer un nombre de 3 chiffres (sans zéro) :

import random

def generer_nombre():

    nombre = 0

    position = 0
    chiffre_aleatoire = random.randint(1, 9)
    nombre += chiffre_aleatoire * 10 ** position   # 10**0 = 1

    position = 1
    chiffre_aleatoire = random.randint(1, 9)
    nombre += chiffre_aleatoire * 10 ** position   # 10**1 = 10

    position = 2
    chiffre_aleatoire = random.randint(1, 9)
    nombre += chiffre_aleatoire * 10 ** position   # 10**2 = 100

    return nombre

resultat = generer_nombre()
print(f"Nombre généré : {resultat}")

Modifier le code afin de retirer la répétition de code (à l'aide d'une boucle).
Ajouter un paramètre optionnel à la fonction pour indiquer la longueur du nombre à générer (par défaut 3).

Notions visées

Boucles (for/while), refactorisation (DRY), définition de fonction, paramètre avec valeur par défaut, module random, opérateurs arithmétiques (puissances de 10)

Exercice - Affichage d'étoiles - DRY : boucle imbriquée

📁 Créez un fichier r05_etoile_1.py pour votre réponse.

Nous allons transformer un code répétitif affichant des lignes d’étoiles sur plusieurs lignes
en une version plus propre et flexible grâce à l’utilisation de boucles.

#Ligne #1
print('*', end='')
print()

#Ligne #2
print('*', end='')  # Affiche une étoile et évite le saut de ligne
print('*', end='')
print()             # Génère une ligne vide

#Ligne #3
print('*', end='')
print('*', end='')
print('*', end='')
print()

#Ligne #4
print('*', end='')
print('*', end='')
print('*', end='')
print('*', end='')
print()

🪜 ÉTAPES À SUIVRE

📌 COMPRENDRE LE MOTIF
Exécutez le code dans PyCharm et observez le motif affiché.
Chaque ligne contient un nombre croissant d’étoiles, allant de 1 à 4.
🔍 IDENTIFIER LA RÉPÉTITION
Tentez d'observer la répétition et tentez de voir comment on peut généraliser le tout.
Pour chaque ligne, vous remarquez qu'on fait toujours les mêmes 2 actions :
- Afficher un nombre variable d'étoiles selon la ligne
- Puis réaliser un saut de ligne.
🔁 PLANIFIER LA RÉSOLUTION À L'AIDE DE BOUCLES
Vous aurez besoin d'une boucle pour répéter ces 2 ensembles d'actions pour chacune des lignes.
Petit problème : le nombre d'instructions pour afficher des étoiles est variable selon la ligne... que faire?
Vous allez avoir besoin d'une boucle pour représenter la création des étoiles!
Vous aurez donc une boucle de création de lignes, et à l'intérieur une boucle de création d'étoiles.
👨🏻‍💻 CODER
Vous avez assez philosophié, maintenant codez!
Lorsque vous avez fini, votre code sera générique et flexible!
Vous seriez capable d'afficher 20 lignes au lieu de 4 avec un p'tit changement mineur!

Notions visées

Boucles imbriquées (for), affichage sans saut de ligne (end), identification de répétitions, généralisation d'un motif

✏️ Exercices sur papier

Documentation interdite et sans PyCharm

Faites ces exercices d'abord sur papier (ou dans un éditeur de texte simple) et sans aucune documentation, comme à l'examen.
Vous pouvez valider votre réponse dans PyCharm à la fin — un luxe que vous n'aurez pas le jour de l'examen, d'où l'importance de vous entraîner sans lui.

Exercice - Cote de passage

📁 Créez un fichier r05_cote_passage.py pour votre réponse.

Une liste de notes est déjà déclarée dans votre programme :

notes = [72, 45, 88, 55, 91, 60, 38]

Écrivez le reste du programme qui parcourt cette liste et affiche, pour chaque note, si l'étudiant a réussi (≥ 60) ou échoué. À la fin, affichez le nombre total de réussites.

Exemple de sortie attendu :

→ Réussi
→ Échoué
→ Réussi
→ Échoué
→ Réussi
→ Réussi
→ Échoué
Nombre de réussites : 4

Notions visées

Boucle for sur une liste, if/else, variable accumulatrice, f-string

🎯 Solutions des exercices

Un solutionnaire possible pour chaque exercice est disponible en format vidéo avec des explications. Vous pouvez vous en servir pour comparer votre solution avec une solution possible jugée optimale et vous débloquer après un long moment bloqué sur un exercice (ex. 20 minutes) et après avoir utilisé le débogueur pour essayer par vous-même de trouver le problème.

attention

Il est tout à fait normal que certains problèmes demandent du temps, de la réflexion, et parfois même un peu de frustration. C’est précisément dans ces moments d’effort que l’apprentissage s’ancre réellement.

Consulter un solutionnaire avant d’avoir tenté l’exercice par soi-même, ou le parcourir trop rapidement, revient à court-circuiter le processus d’apprentissage. Ce n’est pas simplement contre-productif, c’est pédagogiquement désastreux.

En sautant l’étape de la réflexion personnelle, on prive son cerveau de l’occasion de construire des connexions durables. Et à force de répéter ce réflexe, on risque de passer à côté des compétences essentielles, ce qui peut mener à des échecs plus tard, même si tout semble facile sur le moment. Alors oui, prenez le temps. L’erreur fait partie du jeu. C’est en cherchant, en tâtonnant, en doutant, qu’on devient réellement compétent. Le solutionnaire doit être un outil de validation, pas un raccourci.

✏️ Solution des exercices de compréhension :

Débogue et compte — solutionnaire.pdf
Evalue une expression — solutionnaire.pdf

🔨 Solution des exercices de création :

Afficher 5 chiffres aléatoires
Générateur jusqu'à la cible
Jeu de devinette numérique
Remplir et analyser une liste
Umbrella Corporation, version boucle
Calculer des statistiques
Énumérer des décimales (solutionnaire à venir)
Générer un nombre - DRY : boucle simple
Affichage d'étoiles - DRY : boucle imbriquée

✏️ Solution des exercices sur papier :

Cote de passage

La fonction input()​

🕵️‍♂️ Trace d’exécution avec des structures répétitives​

Code​

Trace​

Code​

Trace​

🧠 Auto-validation des connaissances​

✏️ Exercices de compréhension​

🎯 Solutionnaires

✏️ Exercices de compréhension​

🔨 Exercices de création​

🎯 Pour aller plus loin​

PARTIE 1 - Construire la liste avec une boucle​

PARTIE 2 - Parcourir la liste par index​

🎯 Pour aller plus loin​

🛠️ INSTRUCTIONS​

🎯 Pour aller plus loin​

PARTIE 1 : Compteur, somme et moyenne​

PARTIE 2 : Minimum et maximum​

🎯 Pour aller plus loin​

PARTIE 1 - Observer​

PARTIE 2 - Comparer avec round()​

🎯 Pour aller plus loin​

🪜 ÉTAPES À SUIVRE​

✏️ Exercices sur papier​

La fonction `input()`

🕵️‍♂️ Trace d’exécution avec des structures répétitives

Code

Trace

Code

Trace

🧠 Auto-validation des connaissances

✏️ Exercices de compréhension

✏️ Exercices de compréhension

🔨 Exercices de création

🎯 Pour aller plus loin

PARTIE 1 - Construire la liste avec une boucle

PARTIE 2 - Parcourir la liste par index

🎯 Pour aller plus loin

🛠️ INSTRUCTIONS

🎯 Pour aller plus loin

PARTIE 1 : Compteur, somme et moyenne

PARTIE 2 : Minimum et maximum

🎯 Pour aller plus loin

PARTIE 1 - Observer

PARTIE 2 - Comparer avec `round()`

🎯 Pour aller plus loin

🪜 ÉTAPES À SUIVRE

✏️ Exercices sur papier