Les boucles

Une structure en boucle permet de répéter une séquence d’instructions (une portion de code) autant de fois que nécessaire.

Elles rendent possible le parcours de certaines séquences comme les chaînes de caractères, les listes, les dictionnaires …

for … in … :

Une boucle for … in … :  est utilisée lorsqu’on veut répéter une séquence d’instructions un nombre prédéfini de fois : c’est à dire lorsqu’on sait à l’avance combien de fois la répétition doit avoir lieu.

La structure générale d’une boucle for … in … :  est la suivante :

for variable in itérateur:
   <instruction>
   <instruction>
   ...

Que l’on peut traduire par :

affecter successivement à une variable la valeur de chaque élément d’un itérateur et faire …

Un itérateur est un objet itérable, c’est à dire un objet que l’on peut « parcourir ».

On peut ainsi parcourir une liste :

for a in [1, 2, 3]:
   print(a*2)

… un tuple :

for e in ('a', 'b', 'c'):
   print(e.upper())   # la méthode .upper() renvoie le texte en MAJUSCULES

… mais aussi une chaîne de caractères :

t = ""
for c in "fantastique !":
   t = c + t
print(t)

Et il existe diverses façons de parcourir un dictionnaire :

parcourir ses clefs …

dic = {"a" : 12, "b" : 9, "c" : 3}
for k in dic:
   print(k)

for k in dic.keys():
   print(k)

… ses valeurs …

for v in dic.values():
   print(v)

… où encore les deux …

for k, v in dic.items():
   print(k, v)

Cette dernière forme montre comment parcourir un tableau (= une liste de listes) :

liste = [(1, 2), ('a', 'b'), (True, False)]
for x, y in liste:
   print(x, y)

range()

Si on désire répéter une séquence d’instructions un certain nombre de fois, il faudra créer un itérateur spécialement pour cette occasion. On utilise la fonction range()  :

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(4,10))
[4, 5, 6, 7, 8, 9]

>>> list(range(4, 10, 2))
[4, 6, 8]

for i in range(3, -1, -1):
   print(i, "!")

Remarque : il faut convertir l’objet range en liste pour pouvoir afficher son contenu avec print() , mais c’est inutile en revanche pour l’utiliser dans une boucle for … in … :  .

 

enumerate()

Lorsqu’on parcoure un objet itérable, on veut parfois connaitre l’indice de l’itération.

La fonction enumerate()  permet d’obtenir une liste de tuples (indice, valeur)  :

>>> saisons = ['printemps', 'été', 'automne', 'hiver']
>>> enumerate(saisons)
<enumerate object at 0x7f536c1fd798>
>>> list(enumerate(saisons))
[(0, 'printemps'), (1, 'été'), (2, 'automne'), (3, 'hiver')]

objet enumerate  que l’on peut parcourir :

t = ""
for i, c in enumerate("fantastique !"):
   t = c + str(i) + t

Exercices :

• Écrire une fonction table(n)  qui affiche la table de multiplication par \(n\). Le résultat devra être affiché sous la forme :
  • 6 fois 1 font 6
  • 6 fois 2 font 12
  • …
• Un nombre est premier s’il est divisible uniquement par 1 et par lui-même. Écrire une fonction premiers(n)  qui affiche tous les nombres premiers inférieurs à \(n\).

 

---

while … :

Une boucle while … :  est utilisée lorsqu’on veut répéter une séquence d’instructions un nombre de fois non prédéterminé : c’est à dire lorsqu’on ne sait pas à l’avance combien de fois il faudra faire la répétition.

La structure générale d’une boucle while … :  est la suivante :

while condition de fin:
   <instruction>
   <instruction>
   ...

Ce qui peut se traduire par :

tant que cette condition est vraie,

faire …

Cette structure permet également de parcourir des itérateurs (mais pas obligatoirement en entier),

i = 0
while i < len(liste):
   print(liste[i])
   i += 1

mais aussi de réaliser toutes sortes d’actions répétitives :

 

Attention : une boucle while … :  mal écrite peut être infinie !

Exemple, si on oublie d’incrémenter la variable qui sert de condition de fin :

i = 0
while i < 10:
   print(i)

Exercice :

Écrire une fonction somme2(n)  qui renvoie la somme des carrés des $n$ premiers entiers.

 

 

---

break

Le mot-clé break  permet d’interrompre une boucle avant la fin « normale ».

Son usage simplifie parfois les choses :

Soit une liste contentant les résultats de lancés de 2 dés :

liste = [(5, 2), (6, 3), (4, 1), (2, 2)]

On souhaite en extraire le premier couple dont la somme vaut 5.

for x, y in liste:
   if x + y == 5:
      break
print(x, y)

.. est équivalente à :

i = 0
while sum(liste[i]) != 5 and i < len(liste)-1:
   i += 1
   r = liste[i]
print(r)

Cette dernière forme se termine « normalement », mais est un peu moins claire, non ?

Remarque : si aucun lancé n’a la valeur 5, cela donne un résultat inattendu, non géré ici !

Exercice :

• Compléter le  code ci-dessus de manière à gérer le cas où aucun lancé ne fait 5.

---

continue

Le mot-clé continue  permet de continuer une boucle, en repartant directement à la ligne du while … :  ou for … in … :  .

Par exemple, dans le cas des dés :

for x, y in liste:
   if x + y != 5:
      continue
   print(x, y)

Dépôt de fichier réponse