2.3. Instructions itératives.

Les boucles permettent de réaliser plusieurs fois la même série d’instructions. On distingue deux types de boucles :

• les boucles bornées (for) : on sait quand la boucle va s’arrêter.

• les boucles non bornées (while) : on impose une condition d’arrêt de la boucle sans savoir quand elle sera réalisée.

2.3.1. Boucle for

2.3.1.1. Un exemple

L = [1, 3, 5, 7, 9]

for n in L:
	print(n**2)

1
9
25
49
81

2.3.1.2. Syntaxe

• Début de la boucle : for variable_d_iteration in objet_iterable: : le : est obligatoire

• Eviter d’utiliser comme variable_d_iteration une variable qui existe déjà.

• Un objet_iterable est un objet qui contient plusieurs éléments et qui peut être parcouru (itéré). La variable_d_iteration prendre comme valeur à chaque tour de boucle les différents éléments. Pour nous les objet_iterable sont :

  • les listes

  • les vecteurs numpy (cf. suite)

  • des objets créés pour la boucle comme range(5) qui va créer une suire de nombres (0, 1, 2, 3, 4)

• Le corps de la boucle (série d’instruction à exécuter en boucle) doit être indenté.

2.3.1.3. Exemple

• A partir d’une liste déjà créée : cf. l’exemple précédent.

• On utilise range(n) :

for n in range(4):  # On aura donc n=0, n=1, n=2, n=3 et on sort de la boucle
	print(n**2)

0
1
4
9

Important

La “liste” créée par range(n) commence à 0 et s’arrête à n-1

2.3.1.4. Aller plus loin avec range

La syntaxe précédente range(n) suffit en général. Mais il existe une autre syntaxe plus complète : range(start, stop, step) qui créé une suite de nombre partant de start inclus jusqu’à stop non inclus par pas de step

Exemples

• range(3, 8, 2) crée la suite de nombres 3, 5, 7

• range(3, 9, 2) crée la suite de nombres 3, 5, 7 (pas le 9 qui est exclus)

• range(3, 5, 2) crée la suite de nombres 3

• range(7, 5, 1) crée une suite vide puisque 7 est plus grand que 5

On peut aussi utiliser un pas négatif (avec start > stop) :

• range(8, 4, -1) crée la suite de nombres 8, 7, 6, 5

C’est un détail pour nous mais range(n) ne crée pas une liste (on peut s’en rendre compte en demande print(range(3)) ou type(range(3))). Si on veut le transformer en liste, il faudra écrire list(range(3)). Cela dit, il est conseillé alors d’utiliser un vecteur numpy (cf. suite).

2.3.2. Boucle while

2.3.2.1. Un exemple

i = 0  # Initialisation
while i < 4:
	print(i ** 3)
	i = i + 1  # Incrémentation

0
1
8
27

2.3.2.2. Syntaxe

• Initialisation : Une boucle nécessite en général une initialisation (précédemment définir le i et lui donner une valeur de départ).

• while condition: : le : est obligatoire

• le bloc d’instruction doit être indenté.

• le bloc d’instruction doit contenir une instruction qui modifie la condition : sinon on crée un boucle infinie ! (précédemment, l’incrémentation modifie la valeur de i et donc la condition).

Un microcontrolleur (comme Arduino) est programmé avec une boucle infinie pour réaliser sans fin les instructions qu’on lui a donné. Dans nos programmes, on le fera rarement…

2.3.2.3. Exemple

"""On va remplir une liste avec le carré des entiers n tant que n^2 - 2n < 5.
On ne peut utiliser une boucle for car on ne sait pas jusqu'à quel n aller.
"""
N = 5

""" Initialisation de la boucle """
l = []  # Création de la liste qu'on va remplir
n = 0  # Initialisation des entiers.

while n**2 - 2*n < N:  # Condition à vérifier
	l.append(n**2)  # Importance de l'initialisation : sinon on ne peut ajouter de valeur à la liste.
	n = n + 1  # Sans l'incrémentation, n garde la même valeur et la boucle est infinie.

print(l)

[0, 1, 4, 9]

2.3.3. Pour vous entraîner

Voici le lien vers les exercices pour vous entraîner