Programme Officiel
   Contenus
  Capacités attendues
      Commentaires
Constructions élémentaires Mettre en évidence un corpus de constructions élémentaires. boucles non bornées, appels de fonction. Séquences, affectation, conditionnelles, boucles bornées,
Lien vers le programme complet

Comme nous l’avons déjà vu, les boucles permettent de répéter des instructions. Nous détaillerons dans ce chapitre la syntaxe de la fonction range() en Python utile pour contrôler les boucles bornées for, et verrons les trois étapes essentielles à la construction d’une boucle while: initialisation, condition d’arrêt et mise à jour.

Il existe deux façons de coder des boucles en Python:

  • la boucle for en français pour, répète les instructions pour des valeurs choisies.

  • la boucle while en français tant que, répète les instructions tant qu’une condition est vérifiée

Les deux types de boucles sont interchangeables, on préfère cependant utiliser:

  • for si le nombre d’itérations est connu à l’avance.
  • while sinon.

La boucle for

La boucle for est utilisée lorsque l’on connaît à l’avance les valeurs pour lesquelles on veut répéter le bloc d’instructions. On l’appelle une boucle bornée.

Utilisation de la fonction range()

La fonction range() peut accepter de 1 à 3 paramètres pour contrôler la façon dont se font les itérations.

Il est très fréquent de réaliser des itérations sur des nombres en comptant les tours de boucles.

La fonction range(n) permet de créer une boucle de n tours.

for i in range(7):
    print(i)
0
1
2
3
4
5
6

On peut éventuellement choisir la valeur du compteur au départ.

for i in range(début, fin):
    ...

Attention: Dans tous les cas le nombre final n’est pas inclus dans les itérations.

for i in range(1, 7):
    print(i)
1
2
3
4
5
6

On peut également choisir le pas de l’incrémentation grâce à la syntaxe:

for i in range(début, fin, pas):
    instruction 1
    instruction 2
...
for i in range(1, 12, 2):
    print(i)
1
3
5
7
9
11
for i in range(365, 300, -5):
    print(i)
365
360
355
350
345
340
335
330
325
320
315
310
305

Boucles imbriquées

Il est possible d’exécuter une boucle à l’intérieur d’une autre boucle, elles sont alors dites imbriquées.

for mois in range(1, 13):
    for jour in range(1,31):
        print(jour, "/", mois)
1 / 1
2 / 1
3 / 1
4 / 1
5 / 1
6 / 1
7 / 1
8 / 1
9 / 1
10 / 1
11 / 1
12 / 1
13 / 1
14 / 1
15 / 1
16 / 1
17 / 1
18 / 1
19 / 1
20 / 1
21 / 1
22 / 1
23 / 1
24 / 1
25 / 1
26 / 1
27 / 1
28 / 1
29 / 1
30 / 1
1 / 2
2 / 2
3 / 2
4 / 2
5 / 2
6 / 2
7 / 2
8 / 2
9 / 2
10 / 2
11 / 2
12 / 2
13 / 2
14 / 2
15 / 2
16 / 2
17 / 2
18 / 2
19 / 2
20 / 2
21 / 2
22 / 2
23 / 2
24 / 2
25 / 2
26 / 2
27 / 2
28 / 2
29 / 2
30 / 2
1 / 3
2 / 3
3 / 3
4 / 3
5 / 3
6 / 3
7 / 3
8 / 3
9 / 3
10 / 3
11 / 3
12 / 3
13 / 3
14 / 3
15 / 3
16 / 3
17 / 3
18 / 3
19 / 3
20 / 3
21 / 3
22 / 3
23 / 3
24 / 3
25 / 3
26 / 3
27 / 3
28 / 3
29 / 3
30 / 3
1 / 4
2 / 4
3 / 4
4 / 4
5 / 4
6 / 4
7 / 4
8 / 4
9 / 4
10 / 4
11 / 4
12 / 4
13 / 4
14 / 4
15 / 4
16 / 4
17 / 4
18 / 4
19 / 4
20 / 4
21 / 4
22 / 4
23 / 4
24 / 4
25 / 4
26 / 4
27 / 4
28 / 4
29 / 4
30 / 4
1 / 5
2 / 5
3 / 5
4 / 5
5 / 5
6 / 5
7 / 5
8 / 5
9 / 5
10 / 5
11 / 5
12 / 5
13 / 5
14 / 5
15 / 5
16 / 5
17 / 5
18 / 5
19 / 5
20 / 5
21 / 5
22 / 5
23 / 5
24 / 5
25 / 5
26 / 5
27 / 5
28 / 5
29 / 5
30 / 5
1 / 6
2 / 6
3 / 6
4 / 6
5 / 6
6 / 6
7 / 6
8 / 6
9 / 6
10 / 6
11 / 6
12 / 6
13 / 6
14 / 6
15 / 6
16 / 6
17 / 6
18 / 6
19 / 6
20 / 6
21 / 6
22 / 6
23 / 6
24 / 6
25 / 6
26 / 6
27 / 6
28 / 6
29 / 6
30 / 6
1 / 7
2 / 7
3 / 7
4 / 7
5 / 7
6 / 7
7 / 7
8 / 7
9 / 7
10 / 7
11 / 7
12 / 7
13 / 7
14 / 7
15 / 7
16 / 7
17 / 7
18 / 7
19 / 7
20 / 7
21 / 7
22 / 7
23 / 7
24 / 7
25 / 7
26 / 7
27 / 7
28 / 7
29 / 7
30 / 7
1 / 8
2 / 8
3 / 8
4 / 8
5 / 8
6 / 8
7 / 8
8 / 8
9 / 8
10 / 8
11 / 8
12 / 8
13 / 8
14 / 8
15 / 8
16 / 8
17 / 8
18 / 8
19 / 8
20 / 8
21 / 8
22 / 8
23 / 8
24 / 8
25 / 8
26 / 8
27 / 8
28 / 8
29 / 8
30 / 8
1 / 9
2 / 9
3 / 9
4 / 9
5 / 9
6 / 9
7 / 9
8 / 9
9 / 9
10 / 9
11 / 9
12 / 9
13 / 9
14 / 9
15 / 9
16 / 9
17 / 9
18 / 9
19 / 9
20 / 9
21 / 9
22 / 9
23 / 9
24 / 9
25 / 9
26 / 9
27 / 9
28 / 9
29 / 9
30 / 9
1 / 10
2 / 10
3 / 10
4 / 10
5 / 10
6 / 10
7 / 10
8 / 10
9 / 10
10 / 10
11 / 10
12 / 10
13 / 10
14 / 10
15 / 10
16 / 10
17 / 10
18 / 10
19 / 10
20 / 10
21 / 10
22 / 10
23 / 10
24 / 10
25 / 10
26 / 10
27 / 10
28 / 10
29 / 10
30 / 10
1 / 11
2 / 11
3 / 11
4 / 11
5 / 11
6 / 11
7 / 11
8 / 11
9 / 11
10 / 11
11 / 11
12 / 11
13 / 11
14 / 11
15 / 11
16 / 11
17 / 11
18 / 11
19 / 11
20 / 11
21 / 11
22 / 11
23 / 11
24 / 11
25 / 11
26 / 11
27 / 11
28 / 11
29 / 11
30 / 11
1 / 12
2 / 12
3 / 12
4 / 12
5 / 12
6 / 12
7 / 12
8 / 12
9 / 12
10 / 12
11 / 12
12 / 12
13 / 12
14 / 12
15 / 12
16 / 12
17 / 12
18 / 12
19 / 12
20 / 12
21 / 12
22 / 12
23 / 12
24 / 12
25 / 12
26 / 12
27 / 12
28 / 12
29 / 12
30 / 12

La boucle while

La boucle while est plus puissante que la boucle for, elle permet de créer des répétitions, même si l’on ne connait pas à l’avance le nombre de répétitions.

Contrairement à la boucle for, le nombre d’itérations n’est pas fixé à l’avance, mais il est testé dynamiquement au début de chaque boucle: On parle de boucle non bornée.

À chaque tour, on teste une condition, si cette condition est vérifiée, on exécute le bloc d’instructions de la boucle, sinon, l’exécution de la boucle est arrêtée et le programme se poursuit «normalement».

Souvent, il faut initialiser une variable qui contrôle l’itération avant de commencer la boucle.

Contrôle par variable booléenne

Nous créons ici une variable booléenne repeat pour bien comprendre si la boucle while doit se poursuivre ou non.

repeat = True;
while repeat:
    resultat = int(input("Combien font 2 + 5?  "))
    if resultat == 7:
        print("Bravo vous avez trouvé.")
        repeat = False

Il serait cependant plus élégant de faire passer la condition du if dans le while.

resultat = -1
while resultat != 7:
    resultat = int(input("Combien font 2 + 5?  "))
print("Bravo vous avez trouvé.")

Contrôle à l’aide d’un compteur

Ceci ne peut fonctionner que si on connait à l’avance le nombre de tours de boucles. On préférera alors souvent utiliser un for.

On va cependant détailler cette structure, car elle est très commune et illustre bien le mode de pensée que doit acquérir un programmeur.

compteur = 1;                 # initialisation
while compteur <= 5:          # condition
    print(compteur)
    compteur = compteur + 1   # incrémentation du compteur
1
2
3
4
5

On peut découper cette structure de code en trois phases: l’initialisation, la condition et l’incrémentation.

  • L’initialisation se produit une seule fois, au début de l’exécution.
  • La condition d’arrêt est évaluée avant chaque tour de boucle. Si elle est vraie, un nouveau tour de boucle est effectué. Sinon, la boucle est terminée.
  • L’étape ou incrémentation est réalisée après chaque tour de boucle.

Remarques

  • La variable compteur est souvent notée i;

  • faire attention à ne pas programmer une boucle infinie qui bloquerait votre programme en lui faisant répéter l’instruction une infinité de fois et saturerait ainsi votre processeur et votre mémoire.

    i = 0
    while i >= 0:
        print(i)
        i = i + 1
        # i sera toujours positif, la condition d'arrêt ne sera jamais vraie