Boucles.

• Répéter un bloc un nombre connu de fois, ou jusqu’à ce qu’une condition change.
• Calculer une somme, un maximum, compter des occurrences.
• Dérouler une boucle « à la main » pour prédire son résultat.
• Écrire la boucle principale d’un robot simulé.

range(n) : de 0 à n−1. range(a, b) : de a à b−1. range(a, b, pas) : de a vers b par sauts de pas, sans atteindre b. Un pas négatif compte à rebours : range(10, 0, -1) donne 10, 9, …, 1. Testez chacune dans l’éditeur ci-dessus.

On dit que le for itère sur une séquence (chaîne, liste, range…). La variable de boucle prend successivement chaque élément. Vous verrez à la séance 06 que beaucoup d’objets sont parcourables ainsi, et à la séance 17 comment créer les vôtres.

Avant d’exécuter, faites un tableau : une colonne n, une colonne total. Ligne par ligne : n=1 total=1, n=2 total=3, n=3 total=6… C’est fastidieux et c’est exactement ce qu’il faut faire quand un programme ne donne pas ce qu’on attend. Les correcteurs de concours vous demanderont de « dérouler » un algorithme : entraînez-vous dès maintenant.

Si toutes les mesures étaient négatives (température en hiver !), maximum = 0 resterait à 0 et serait faux. Partir du premier élément est la seule initialisation toujours correcte. Réfléchir aux valeurs limites (liste vide, négatifs, un seul élément) est un réflexe indispensable.

Si la condition ne devient jamais fausse, le programme ne s’arrête plus. Enlevez la ligne altitude -= vitesse : la page se bloquera (rechargez-la). Dans un vrai terminal, Ctrl+C interrompt. Règle : dans un while, quelque chose dans le bloc doit faire progresser la condition vers False. Vérifiez-le à chaque fois que vous en écrivez un.

Un break bien placé rend le code plus clair (« on a trouvé, on arrête »). Trop de break et continue dispersés rendent une boucle imprévisible. Si vous en avez plus de deux dans une boucle, il y a sans doute une façon plus simple de l’écrire.

.isdigit() est vrai si la chaîne ne contient que des chiffres. On teste d’abord cela, et seulement ensuite on convertit : grâce à or, si not reponse.isdigit() est vrai, Python n’évalue pas la deuxième partie (évaluation « paresseuse ») et int("abc") n’est jamais tenté. Ce détail est une vraie protection, pas une coïncidence. Testez en tapant « abc », « 250 », puis « 42 ».

for i in range(1, 11):
    print(f"7 x {i} = {7 * i}")

for n in range(10, 0, -1):
    print(n)
print("Décollage !")

n = int(input("Un entier positif ? "))
somme = 0
nb_chiffres = 0
while n > 0:
    somme += n % 10       # le chiffre des unités
    n = n // 10           # on retire ce chiffre
    nb_chiffres += 1
print(f"Somme des chiffres : {somme}, nombre de chiffres : {nb_chiffres}")

Déroulez pour n = 472 : (472, 0) → (47, 2) → (4, 9) → (0, 13). La condition n > 0 progresse bien vers faux car n // 10 finit toujours par atteindre 0. Cas limite : n = 0 donne 0 chiffre… est-ce ce qu’on veut ? Corrigez si nécessaire.

def temps_de_vol(n):
    etapes = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        etapes += 1
    return etapes

print("27 :", temps_de_vol(27), "étapes")

record, champion = 0, 1
for n in range(1, 1001):
    t = temps_de_vol(n)
    if t > record:
        record, champion = t, n
print(f"Champion : {champion} avec {record} étapes")

27 met 111 étapes et grimpe jusqu’à 9232. Le champion sous 1000 est 871 (178 étapes). On a utilisé une fonction (séance 05) pour ne pas écrire la boucle deux fois : c’est un avant-goût. Ce problème est célèbre parce qu’il est trivial à programmer et que personne n’a réussi à prouver que la boucle while se termine toujours. Le mathématicien Paul Erdős a dit : « les mathématiques ne sont pas encore prêtes pour de tels problèmes ».

Exécutez plusieurs fois. Puis : (1) baissez la batterie de départ à 20 et observez ; (2) ajoutez un compteur d’obstacles rencontrés ; (3) faites en sorte que le robot recule de 5 cm quand il rencontre un obstacle deux fois de suite. Cette structure « tant que la mission n’est pas finie : percevoir, décider, agir » est celle de tout robot réel. Sur Arduino, elle s’appelle loop() et tourne toute seule.