Les boucles for

Contenu

Les boucles `for`#

Motivation#

Revenons sur notre programme pour compter de 1 à 5 :

n = 1

while n <= 5:
    print(n)
    n = n + 1 

Il suit un schéma classique de programme avec un compteur :

    initialisation

    while condition:
        bloc d instructions
        incrémentation
    

L” initialisation (initialisation) n = 1 détermine à partir de quelle valeur on compte;
L” incrémentation (incrementation) n = n + 1 détermine par pas de combien on compte;
La condition (condition) n <= 5 détermine jusqu’à quelle valeur on compte.

Problème :

La gestion du compteur est dispersée : le lecteur doit chercher à trois endroits pour avoir toutes les informations sur le compteur. L’incrémentation notamment se retrouve loin si le bloc d’instructions est long.

Pour pallier cela, la plupart des langages de programmation introduisent la boucle for : «pour … de … à … faire …». Voici comment cela s’écrit en Python sur notre exemple :

for i in range(1, 6):
    print(i)

Litéralement cela se traduit par : « pour i dans la séquence de 1 à 6 exclu, afficher i ».

La fontion range()#

Définition : La fonction range()

La fonction range renvoie une séquence d’entiers. Elle est souvent utilisée dans les boucles pour répéter une action un certain nombre de fois. Elle peut-être utilisée sous trois formes :

range(fin) : génère une séquence d’entiers de 0 à fin exclu.
range(début, fin) : génère une séquence d’entiers de début à fin exclu.
range(début, fin, pas) : génère une séquence d’entiers de début à fin exclu, par pas de pas.

Affiche les nombres de 0 à 4 :

for i in range(5):
    print(i) 

Affiche les nombres de 1 à 5 :

for i in range(1, 6):
    print(i) 

Affiche les nombres impairs (par pas de 2) entre 1 et 9 :

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

Le pas peut également être négatif :

for i in range(5, 0, -1):
    print(i) 

Définition : boucle for

Syntaxe :

for i in range(début, fin, pas):
    # bloc d'instructions

Sémantique

Initialisation : au début de la boucle, Python extrait la première valeur donnée par \(range()\), et elle est placée dans la variable temporaire \(i\).
Bloc d’instructions : le bloc sous la boucle est exécuté.
Itération : Python extrait le prochain élément donné par \(range()\) et affecte sa valeur à la variable \(i\).
Fin de boucle : La boucle se termine lorsque toutes les valeurs ont été parcourues.

Dans les exemples précédents, nous avons utilisé \(range()\), qui génère une séquence d’entiers : la boucle \(for\) fonctionne aussi en itérant sur d’autres types de données telles que les listes ; nous y reviendrons plus tard dans le cours.

Exercice : comptons!#

Copiez l’instruction for ci-dessous dans la cellule suivante, et remplacez les trois « ? » par les valeurs appropriées pour afficher les entiers pairs entre 0 et 20 (0,2,4,…,20) :
```
  for i in range(?, ?, ? ):
      print(i)
  
```

### BEGIN SOLUTION
for i in range(0, 21, 2):
    print(i)
### END SOLUTION

Écrivez des boucles for qui affichent les nombres suivants dans l’ordre donné :

0, 3, 6, 9, 12 :

### BEGIN SOLUTION
for i in range(0, 13, 3):
    print(i)
### END SOLUTION

20, 21, 22, 23, 24, 25 :

### BEGIN SOLUTION
for i in range(20, 26): 
    print(i)
### END SOLUTION

10, 9, 8, 7, 6, 5, 4, 3, 2, 1 :

### BEGIN SOLUTION
for i in range(10, 0, -1):
    print(i)
### END SOLUTION

Utilisation de la boucle for dans Laby#

Relevez le défi Laby ci-dessous si vous ne l’avez pas encore fait en Semaine 1 :

from laby.global_fr import *
Laby("counting-the-rocks")

### BEGIN SOLUTION
# Prend le caillou qui est devant et le pose derrière
def deplace_caillou_derriere():
    prend()
    avance()
    gauche() 
    gauche()
    pose()
    gauche()
    gauche()
### END SOLUTION

debut()
### BEGIN SOLUTION
avance()
# Avance et pose les cailloux derrière (7 fois)
for i in range(0, 7):
	deplace_caillou_derriere()

# Tourne à gauche puis avance (2 fois)
for i in range(0,2):
    gauche()
    avance() 
    avance()

# Tourne à droite puis avance à travers les cailloux (4 fois)
droite()
for i in range(0,4):
	deplace_caillou_derriere()

# Tourne à droite puis avance à travers les cailloux (5 fois)
droite()
avance()
for i in range(0,5):
	deplace_caillou_derriere()

gauche()
avance() 
avance()
ouvre()
### END SOLUTION

assert est_gagnant()

♣ Écrivez une fonction carre(L) qui prend en paramètre un entier L, et qui fait faire à la fourmi une trajectoire carrée de côté L cases. La fourmi doit revenir à la case de départ à la fin de la fonction.

Laby(carte=
"o o o o o o o o o o o o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o . . . . . . . . . . o\n"
"o ↑ . . . . . . . . . o\n"
"o o o o o o o o o o o o\n"
)

# Entrée : un entier L, correspondant à la longeur d'un côté de la trajectoire.
# Sortie : aucune, déplace la fourmi selon un carré de longueur L
### BEGIN SOLUTION
def carre(L) :
    if (L > 0):
        for i in range(4):
            for j in range(L-1):
                avance()
            droite()
### END SOLUTION

debut()
carre(0)  # La fourmi ne fait rien

debut()
carre(1)  # La fourmi doit faire un tour sur elle-même

debut()
carre(5)  # la fourmi doit parcourir un carré de longueur 5 cases

Bilan#

Astuce

À retenir Lorsque la boucle fait intervenir un compteur, on utilise généralement une boucle for et sinon une boucle while.

Retourner à l’index