Séance 4 : Structures itératives (Pour, Tant que, Répéter...Jusqu'à) & TDO

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue complète (Toutes les phases affichées)' : phases[currentPhase - 1].title }}

Étape 1

Accroche et situation-problème

10 minutes

Énoncé au tableau

« On souhaite saisir un entier N strictement compris entre 2 et 100 (la saisie doit être répétée tant qu'elle n'est pas conforme). On calcule ensuite la somme de ses diviseurs stricts pour tester si le nombre est parfait (un nombre est parfait s'il est égal à cette somme). Enfin, on compte combien de divisions successives entières par 2 ce nombre peut subir tant qu'il reste pair. »

Cette situation-problème fédère de manière exemplaire les trois grandes formes de structures itératives : la boucle post-test avec au moins une saisie, la boucle à compteur à nombre d'itérations fixé, et la boucle pré-test dépendante d'un prédicat de calcul.

Boucle 1

Contrôle de saisie

Structure post-test : Répéter ... Jusqu'à.

Jusqu'à (n > 2) Et (n < 100)

Garantit au moins une première saisie avant vérification de la condition d'arrêt.

Boucle 2

Somme des diviseurs

Boucle complète : Pour i de 1 à n-1.

Pour i de 1 à n - 1 Faire

Le nombre d'itérations est exactement n - 1, connu et fixé dès le départ.

Boucle 3

Divisions par 2

Boucle préalable : Tant que.

Tant que temp Mod 2 = 0 Faire

Condition de continuation évaluée avant chaque division entière par 2.

Questionnement oral (cliquez pour afficher la réponse didactique) :

En Algorithmique :

En Python 3 :

Étape 2

Tableau de correspondance : Algorithmique ↔ Python

15 minutes

Mise au point sur les règles officielles des structures itératives (Conventions 2024-2025) :

Structure	Algorithmique (Norme)	Python (Conventions 2024-2025)
Boucle complète	`Pour i de D à F [Pas = p] Faire Traitement Fin Pour`	`for i in range(D, F + 1, p): Traitement` Borne F+1 exclue en Python
Boucle préalable	`Tant que Condition Faire Traitement Fin Tant que`	`while Condition: Traitement` Condition de maintien / continuation
Boucle post-test	`Répéter Traitement Jusqu'à Condition`	`while not (Condition): Traitement` Négation de la condition d'arrêt

Consignes officielles impératives (Interdictions formelles) :

Proscription absolue du break : L'utilisation de l'instruction break pour forcer la sortie d'une boucle for ou while est formellement interdite.
Intégrité du compteur de boucle Pour : La valeur de la variable de contrôle d'une boucle Pour ne doit jamais être modifiée manuellement dans le traitement.
Division entière : Les calculs de parité et de division itérative doivent employer l'opérateur euclidien // (et non pas /) pour préserver le type int.

Pas négatif dans range

Pour compter à rebours en Python, la borne finale doit être F - 1 pour s'arrêter à F.

# De 10 à 0 décroissant :
range(10, -1, -2)

Inversion de condition

La condition de Jusqu'à indique quand sortir. En Python, le while continue tant que la condition est vraie.

Jusqu'à (n > 2)
while not (n > 2): # ou n <= 2

Prévention de boucle infinie

Dans une boucle while, une variable de la condition doit impérativement être modifiée à chaque itération.

temp = temp // 2
nb_div2 = nb_div2 + 1

Étape 3

Conception algorithmique & T.D.O. Standard

20 minutes

Construction guidée au tableau articulant les trois familles d'itérations en un algorithme cohérent :

ALGORITHME AnalyseNombre Algorithme Principal

ALGORITHME AnalyseNombre
DEBUT
    // 1. Contrôle de saisie post-test
    Répéter
        Écrire("Donner un entier N (2 à 100) : ")
        Lire(n)
    Jusqu'à (n > 2) Et (n < 100)
    
    // 2. Boucle complète : somme des diviseurs stricts
    somme_div ← 0
    Pour i de 1 à n - 1 Faire
        Si n Mod i = 0 Alors
            somme_div ← somme_div + i
        FinSi
    Fin Pour
    
    est_parfait ← (somme_div = n)
    Écrire("Le nombre est-il parfait ? ", est_parfait)
    
    // 3. Boucle préalable : divisions successives par 2
    temp ← n
    nb_div2 ← 0
    Tant que temp Mod 2 = 0 Faire
        temp ← temp Div 2
        nb_div2 ← nb_div2 + 1
    Fin Tant que
    
    Écrire("Nombre de divisions par 2 possibles : ", nb_div2)
FIN

T.D.O. Standard Objets Globaux

Objet	Type / Nature
n, somme_div, i, temp, nb_div2	Entier
est_parfait	Booléen

Rôles des variables dans les boucles :

n : Entier saisi contrôlé dans ]2, 100[.
i : Compteur automatique de la boucle Pour (de 1 à n-1).
somme_div : Accumulateur de somme, initialisé à 0 avant la boucle.
temp : Copie de travail de n pour éviter d'altérer la valeur initiale.
nb_div2 : Compteur incrémenté à chaque division valide par 2.

Étape 4

Traduction, Exécution sur machine & Laboratoire

20 minutes

Implémentation individuelle du script en respectant les conventions d'écriture Python officielles :

analyse_nombre.py

# 1. Contrôle de saisie émulant 'Répéter ... Jusqu'à' sans break
n = 0
while not (2 < n < 100):
    n = int(input("Donner un entier N (2 à 100) : "))

# 2. Somme des diviseurs avec 'for in range' (borne n incluse dans le range via n)
somme_div = 0
for i in range(1, n):
    if n % i == 0:
        somme_div = somme_div + i
est_parfait = (somme_div == n)
print("Le nombre est-il parfait ? :", est_parfait)

# 3. Divisions successives par 2 avec 'while'
temp = n
nb_div2 = 0
while temp % 2 == 0:
    temp = temp // 2
    nb_div2 = nb_div2 + 1
print("Nombre de divisions par 2 possibles :", nb_div2)

Points d'attention & Vigilance enseignant

Vérification de la borne supérieure dans range(1, n) :
Pour tester les diviseurs stricts jusqu'à n - 1, la borne passée à range doit impérativement être n (puisque la fin est exclue).

Usage de la division entière // :
S'assurer que les élèves utilisent temp = temp // 2 et non temp / 2, sous peine de convertir temp en nombre flottant.

Interdiction stricte de while True + break :
Rappeler l'obligation normative de pré-initialiser n = 0 pour amorcer la boucle while not (2 < n < 100):.

Simulateur Interactif : Décomposition des 3 Boucles en Direct

Cas d'école :

Saisir la valeur de N :

n =

Contrôle de conformité de saisie :

{{ isValidInput ? 'Saisie Valide (2 < N < 100)' : 'Saisie Hors Bornes !' }}

{{ isValidInput ? 'La boucle post-test s\'arrête avec succès.' : 'La boucle post-test continue de redemander la saisie.' }}

Boucle 2 (Pour) : Parcours des diviseurs stricts de 1 à {{ nVal - 1 }}

{{ d }} Aucun diviseur strict disponible.

Somme des diviseurs stricts :

{{ divisorsList.join(' + ') || '0' }} = {{ sommeDiv }}

{{ isPerfect ? 'NOMBRE PARFAIT ! (somme = n)' : 'Nombre Non Parfait (somme ≠ n)' }}

{{ isPerfect ? (sommeDiv + ' == ' + nVal + ' -> est_parfait = True') : (sommeDiv + ' ≠ ' + nVal + ' -> est_parfait = False') }}

Boucle 3 (Tant que) : Divisions successives par 2 (temp // 2)

{{ nVal }} temp initial

Valeur finale restante (impaire) : {{ lastOddNumber }}

Nombre total de divisions (nb_div2) : {{ nbDiv2 }}

Sortie console Python (Terminal)

Étape 5

Bilan, Synthèse d'ancrage et Auto-évaluation

5 minutes

Contrôle oral rapide (Questions Flash de clôture) :

Question didactique

Afficher la réponse

Algo : {{ f.resAlgo }}

Quiz d'auto-évaluation interactif

Testez vos compétences sur les boucles Pour, Tant que, Répéter et leur implémentation sans break.

Score : {{ quizScore }} / {{ quizQuestions.length }}

Q{{ idx + 1 }}. {{ q.question }}

Explication didactique : {{ q.explanation }}