5.3. Boucles

Comme dans beaucoup de langages de programmation, il existe deux types de boucles en Python :

  • les boucles inconditionnelles qui permettent d’exécuter un bloc d’instructions un nombre de fois fixé à l’avance ;

  • les boucles conditionnelles qui permettent l’exécution d’un code tant qu’une condition est remplie.

5.3.1. Boucles inconditionnelles

Les boucles inconditionnelles en Python permettent de parcourir un objet de type itérable [3] (comme une liste, un tuple ou une chaîne de caractères) élément par élément.

De manière générale, on utilise les mots-clés for et in.

for <element> in <iterable>:
    <instruction1>
    <instruction2>
    ...

On peut itérer aussi bien sur des listes

In [1]: for elt in [1, 'toto', 2.34]:
   ...:     print(elt)
   ...: 
1
toto
2.34

que sur des tuples

In [2]: for elt in 5, 6, 'tata':    # pas besoin de parenthèses pour le tuple dans ce cas
   ...:     print(elt)
   ...: 
5
6
tata

et même sur des chaînes de caractère.

In [3]: for elt in 'blabla':
   ...:     print(elt)
   ...: 
b
l
a
b
l
a

La fonction range

La fonction range renvoie un itérable contenant des entiers. Plus précisément, lorsque a, b, c sont des entiers (c!=0),

  • range(a) contient les entiers 0, 1, 2, ..., a-2, a-1 (aucun si a <= 0) ;

In [4]: for i in range(5):
   ...:     print(i)
   ...: 
0
1
2
3
4

In [5]: for i in range(-5):
   ...:     print(i)
   ...:

  • range(a, b) contient les entiers a, a+1, a+2, ..., b-2, b-1 (aucun si b <= a) ;

In [6]: for i in range(3, 8):
   ...:     print(i)
   ...: 
3
4
5
6
7

In [7]: for i in range(8, 3):
   ...:     print(i)
   ...:

  • range(a, b, c) contient les entiers a, a+c, a+2c, ... jusqu’à atteindre b exclu (aucun si c*(b-a)<=0).

In [8]: for i in range(4, 9, 2):
   ...:     print(i)
   ...: 
4
6
8

In [9]: for i in range(9, 4, 2):
   ...:     print(i)
   ...: 

In [10]: for i in range(9, 4, -2):
   ....:     print(i)
   ....: 
9
7
5

In [11]: for i in range(4, 9, -2):
   ....:     print(i)
   ....:

5.3.2. Listes en compréhension

En mathématiques, il existe plusieurs manières de décrire un même ensemble. L’ensemble \(\mathcal{A}\) des entiers pairs compris entre 0 et 19 peut être défini en extension :

\[\mathcal{A}=\{0,2,4,6,8,10,12,14,16,18\}\]

Il peut également être décrit en compréhension :

\[\mathcal{A}=\{2n,\;n\in[\![0,9]\!]\}\]

De la même manière, la liste de ces entiers peut être défini en Python en extension :

In [12]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Out[12]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

et en compréhension :

In [13]: [2*n for n in range(10)]
Out[13]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

On parle alors de liste en compréhension.

Une autre manière de définir \(\mathcal{A}\) en compréhension est la suivante :

\[\mathcal{A} = \{x\in[\![0,19]\!],\;x\equiv0[2]\}\]

La version correspondante en Python est :

In [14]: [n for n in range(20) if n%2==0]
Out[14]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Bien entendu, on peut utiliser ce type de liste pour d’autres objets que des entiers [1].

In [15]: [s.upper() for s in ('toto', 'tata', 'titi', 'zozo', 'zaza', 'zizi') if s[0]=='t']
Out[15]: ['TOTO', 'TATA', 'TITI']

5.3.3. Boucles conditionnelles

Une boucle conditionnelle consiste à répéter un bloc d’instructions tant qu’une condition est vraie. On emploie pour cela le mot-clé while.

In [16]: a, b = 15, 6

In [17]: q, r = 0, a

In [18]: while r >= b:
   ....:     q += 1
   ....:     r -= b
   ....: 

In [19]: print(q, r)
2 3

Lorsque l’on « sort » de la boucle while, on est assuré que la condition suivant le mot-clé while est fausse.

Avertissement

Contrairement aux boucles inconditionnelles, il est facile de créer des boucles conditionnelles infinies [2]. En effet, la condition suivant l’instruction while peut s’avérer ne jamais être fausse. On peut par exemple méditer l’exemple suivant qui n’est qu’une très subtile modification de l’exemple précédent.

a, b = 15, -6
q, r = 0, a
while r >= b:
    q += 1
    r -= b
print(q, r)

5.3.4. Les instructions break et continue

Ces deux instructions permettent d’altérer le cours normal d’une boucle.

L’instruction break permet de sortir d’une boucle sans avoir effectué toutes les itérations.

In [20]: i = 0

In [21]: while i < 5:
   ....:     i += 1
   ....:     print(i)
   ....:     break
   ....: 
1

In [22]: for i in range(10):
   ....:     print(i)
   ....:     if i > 5:
   ....:         print("sortie")
   ....:         break
   ....: 
0
1
2
3
4
5
6
sortie

En cas de boucles imbriquées, l’instruction break permet de quitter la boucle la plus interne dans laquelle elle figure.

In [23]: for i in range(5):
   ....:     print('i =', i)
   ....:     for j in range(5):
   ....:         if j > 2:
   ....:             break
   ....:         print('\t j =', j)
   ....: 
i = 0
	 j = 0
	 j = 1
	 j = 2
i = 1
	 j = 0
	 j = 1
	 j = 2
i = 2
	 j = 0
	 j = 1
	 j = 2
i = 3
	 j = 0
	 j = 1
	 j = 2
i = 4
	 j = 0
	 j = 1
	 j = 2

Quant à l’instruction continue, elle permet de terminer l’itération courante et de passer directement à l’itération suivante.

In [24]: s = ""

In [25]: for c in "anticonstitutionnellement":
   ....:     if c == "e":
   ....:         continue
   ....:     s += c
   ....: 

In [26]: print(s)
anticonstitutionnllmnt

In [27]: i = 0

In [28]: while i < 10:
   ....:     i += 1
   ....:     if i % 3 ==0:
   ....:         continue
   ....:     print(i)
   ....: 
1
2
4
5
7
8
10

On remarquera que les instructions break et continue figurent quasiment toujours à l’intérieur d’un test.

Notes