loop

C1-ALGO-12 : Les boucles#

Objectifs pédagogiques#

  • connaître les deux types de boucles en Python

  • savoir dessiner l’algorigramme d’une boucle for et while

  • appliquer sur des problèmes algorithmiques

Définition : une boucle#

Une boucle est une structure de contrôle qui permet de répéter un bloc d’instructions.

Les deux types de boucles#

Il existe deux types de boucles (en Python) :

  1. les boucles bornées : for

  2. les boucles non bornées : while

Quand choisir for ou while ?

Boucle bornée : for#

Lorsque le nombre de répétitions est connu, alors la boucle est bornée et on l’écrira avec un bloc for:

limite = 4
for i in range(limite):
    print("i a pour valeur ", i)

i a pour valeur  0
i a pour valeur  1
i a pour valeur  2
i a pour valeur  3

Toutes les instructions qui suivent les deux points : et qui sont séparées par quatre espaces (ou une tabulation sous Thonny) sont appelées corps de la boucle.

On dit qu’à chaque exécution du corps de la boucle, on réalise une itération.

La variable i qui prend les valeurs successivement de 0 à limite est appelée itérateur (parfois compteur). Il permet de numéroter les itérations.

La fonction range()#

range() est une fonction qui retourne une séquence de nombres. Par défaut, elle commence à 0 et se termine avant une limite spécifiée en incrémentant de 1

perimetre = range(4)
for i in perimetre:
    print(i)

0
1
2
3

La signature de la fonction est :

range(start, stop, step)

où :

  • start est la borne inférieure (comprise) : optionnel

  • stop est la borne supérieure (non-comprise) : obligatoire

  • step est le pas : optionnel

perim = range(3,10,2)
for i in perim:
    print(i)

3
5
7
9

range(start,stop,step) dans une boucle for#

A l’aide de la fonction range(start, stop, step) il est maintenant possible de préciser l’étendue du périmètre de la boucle bornée for.

for i in range(4,10,2):
    print(i)

4
6
8

Boucle for dans un algorigramme#

La boucle for avec la fonction range(start, stop, step) complète (telle que l’exemple ci-dessus) se dessine avec les symboles suivants :

bouclefor

Boucle non-bornée : while#

Lorsque le nombre de répétitions n’est pas connu à l’avance, alors on choisira un bloc while:

x = 1
while x < 10:
    print("x a pour valeur", x)
    x = x * 2
print("Fin")

x a pour valeur 1
x a pour valeur 2
x a pour valeur 4
x a pour valeur 8
Fin

Toutes les instructions qui suivent les deux points : et qui séparées par quatre espaces (ou une tabulation sous Thonny) sont appelées corps de la boucle while.

Le corps de la boucle sera répété tant que la condition est vraie :

while condition :
    instruction1
    instruction2
    etc..

Remarque : si la condition est False au départ, alors le corps de la boucle ne sera jamais exécuté

x = 20
while x < 10:
    print("x a pour valeur", x)
    x = x * 2
print("Fin")

Fin

A l’opposé, si la condition est toujours vraie, alors le programme exécutera indéfiniment le corps de boucle. Ce cas est un exemple d’erreur algorithmique (un algorithme a toujours une fin.

while True:
    print("x a pour valeur", x)
    x = x * 2

Boucle while dans un algorigramme#

La boucle while se dessine avec les symboles suivants :

bouclewhile

Transformation d’une boucle for en boucle while#

Il suffit de déclarer les variables de la fonction range(start, stop, step) ainsi que de l’itérateur.

Exemple :

for i in range(1,8,2):
    print(i)

1
3
5
7

se transforme en la boucle while suivante :

start = 1
stop = 8
step = 2
i = start
while (i < stop):
    print(i)
    i = i + step

1
3
5
7

Exercices#

Pour chaque exercice, choissisez le type de boucle le plus adéquat (for ou while) puis :

  1. Dessinez l’algorigramme

  2. Ecrivez le code Python

Exercice 1#

Problème : on aimerait écrire un jeu de devinette. Il s’agit de découvrir un nombre (variable atrouverde type entier) entre 1 et 100. Le joueur peut faire le nombre d’essais qu’il veut. Lorsqu’il a trouvé le nombre atrouver, le jeu se termine.

Exercice 2#

Problème : on aimerait afficher la somme des nombres impairs compris entre 125 et 1001 (compris)

Exercice 3#

Problème : on aimerait écrire un minuteur. Ce minuteur commence à la variable entière duree (nombre de secondes) et s’arrête à zéro. Attention, si l’utilisateur appuie sur un bouton, le minuteur s’arrête et le programme s’arrête.