IV. Les boucles bornées¶

TP : Introduction aux boucles bornées¶

Les boucles, en programmation, servent à répéter plusieurs les mêmes instructions (ou presque les mêmes instructions). On s'intéresse dans ce TP aux boucles bornées : on sait à l'avance combien de fois elles vont s'exécuter.

On utilise une boucle for pour répéter l'affichage de la chaîne de caractères "NSI". Le nombre de fois que l'instruction est répétée est définie par les paramètres du range(...).
```
for _ in range(5):
    print("NSI")
```
a. Combien de fois cette chaîne apparaît-elle dans la console ? .....................
b. Modifier le code pour que "SNT" s'affiche 10 fois.
```
for i in range(5):
    print(i)
```
a. Qu'est-ce qui a changé dans la syntaxe du for par rapport à la question 1 ? ...................................................
b. Le paramètre du range est toujours 5. Noter la liste des valeurs qui s'affichent, pour ce paramètre : ..................................................
```
for i in range(1, 5):
    print(i)
```
a. Qu'est-ce qui a changé dans la syntaxe du for par rapport à la question 2 ? ..................................................
b. De combien à combien vont les valeurs qui s'affichent ? ..................................................
```
for i in range(5, 1, -1):
    print(i)
```
a. Qu'est-ce qui a changé dans la syntaxe du for par rapport à la question 3 ? ..................................................
b. En vous basant sur l'affichage correspondant à ce code, à quoi peut bien correspondre le -1 écrit dans le range ? ..................................................
Utiliser ce que vous avez vu dans les questions précédentes pour afficher les entiers de 1 à 10 compris.
```
for i in range(1, 10, 2):
    print(i)
```
a. Quelles valeurs le programme affiche-t-il ? ......................................
b. Le modifier pour afficher cette fois-ci les multiples de 3 de 1 à 10 compris.
Afficher, à la manière d'un thermomètre très précis, tous les entiers de 0 à 40 compris.
Afficher tous les entiers de 40 à 0 compris.
Afficher, à la manière d'un thermomètre moins précis, les multiples de 5 en partant de 40 et en allant jusqu'à 0 compris.

Cours¶

Lorsque l'on utilise une boucle non-bornée, on n'a pas à savoir à l'avance combien de fois est-ce que l'on va répéter les opérations. On utilise une boucle bornée (qui a des bornes, de départ et d'arrivée) lorsqu'on le sait.

A. Exemple¶

Pour afficher tous les entiers de 1 à 10 avec une boucle bornée, l'algorithme est le suivant (compléter sa traduction Python) :

Algorithme et code

Pour i de 1 à 10
    afficher i

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

Le i est une variable créée avec la boucle, dont la valeur change automatiquement à chaque nouveau passage = chaque nouvelle itération.

Comment i varie est déterminé par la fonction range : elle permet d'obtenir une séquence de nombres à partir d'un nombre de départ, d'arrivée et éventuellement d'un pas : la différence entre deux nombres successifs de la séquence.

Voici un extrait de sa documentation :

range(stop)
range(start, stop[, step])

start
    The value of the start parameter (or 0 if the parameter was not supplied)
stop
    The value of the stop parameter
step
    The value of the step parameter (or 1 if the parameter was not supplied)

S'il n'y a qu'un paramètre, que désigne-t-il ?

Il désigne la valeur avant laquelle on s'arrête : la dernière valeur prise par la variable est stop-1.

S'il y a 2 paramètres, que désignent-ils ?

Ils désignent la valeur de départ (incluse), et la valeur avant laquelle on s'arrête.

Même question s'il y en a 3.

Ils désignent la valeur de départ, la valeur avant laquelle on s'arrête, et le pas.

Quelle est la valeur de début par défaut ? La valeur du pas par défaut ?

Par défaut, la valeur de début est 0 et la valeur du pas est 1.

B. Cas général¶

Définition

Une boucle bornée permet de répéter des instructions un nombre de fois déterminé à l'avance. On utilise souvent une variable stockant une valeur différente à chaque nouvelle itération.

De manière générale, la valeur contenue dans la variable de la boucle est prise dans une séquence (une suite de valeurs) qui peut être créée grâce à la fonction range.

Algorithme

Pour i dans séquence
    instructions

Pour j variant de 0 à fin-1
    instructions

Pour k variant de debut à fin-1
    instructions

Pour l variant de debut à fin-1 en variant de pas
    instructions

Code

for i in sequence:
    instructions

for j in range(fin):
    instructions

for k in range(debut, fin):
    instructions

for l in range(debut, fin, pas):
    instructions

TD : Les boucles bornées¶

Exercice 1 : Boucles sur des entiers¶

Code

for i in range(1,11):
    print(2*i)

Combien de fois l'intruction de la boucle for va-t-elle être exécutée ?
Compléter la table de trace suivante (en ajoutant le bon nombre de lignes, correspondant au nombre d'itérations) :

Itération i 2*i

1

2
En déduire ce qu'affiche ce programme.
Qu'affichent les programmes suivants ? Vous appliquerez au besoin la même méthode que précédemment (attention aux paramètres du range !).
Code 1
```
for i in range(0,10):
    print(3*i)
```
Code 2
```
for i in range(0,5):
    print(i**2)
```
Code 3
```
for i in range(1,100,10):
    print(i//10)
```

Exercice 2 : boucles bornées et non-bornées¶

Transformer le code suivant pour utiliser une boucle bornée à la place d'une boucle non-bornée. Quelle valeur contient la variable somme, dans les deux cas, après exécution du code ?
Code
```
c = 0
somme = 0
while c < 5:
    somme = somme + c
    c = c+1
```
Transformer le code suivant pour utiliser une boucle non-bornée à la place d'une boucle bornée. Quelle valeur contient la variable total, dans les deux cas, après exécution du code ?
Code
```
total = 0
for i in range(5):
    total = total + i**2
```

Exercice 3 : Boucles sur des chaînes de caractères¶

Une chaîne de caractères stocke plusieurs valeurs, plusieurs caractères. Les différents caractères sont accessibles grâce à leur position dans la chaîne, appelée leur indice.

Le tableau suivant donne l'indice des différents caractères de la chaîne NSI :

Caractère	Indice
`N`	0
`S`	1
`I`	2

On accède aux différents caractères d'une chaîne chaine avec la syntaxe chaine[indice] où indice est un entier compris entre 0 et la longueur de la chaîne - 1.
Avec quelle instruction accéder au caractère S dans la chaîne chaine = 'NSI' ?
Pour parcourir toute la chaîne, on a besoin de sa longueur, que l'on extrait avec la fonction len. Dans notre cas, que vaut len(chaine) ?
Le code Python suivant affiche un à un des différents caractères de c.
Code
```
for i in range(len(chaine)):
    print(chaine[i])
```
Adapter ce code pour stocker dans une nouvelle variable chaine_inversee les caractères de chaine mais dans l'ordre inverse : dans notre cas le caractère d'indice 0 se retrouve à l'indice 2, celui d'indice 2 à l'indice 0.

TP : Dessiner des formes géométriques avec Turtle 2¶

Dans ce TP, on améliore ce qui a été fait dans le premier TP Turtle, en utilisant des boucles.

Voici un code qui permettait de tracer un carré. Vérifier qu'il fonctionne bien en l'exécutant :

from turtle import *

forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)
forward(100)
left(90)

done()

Réecrire ce code sans répéter les instructions qui permettent d'avancer et de tourner, mais en utilisant une boucle for à la place.
Ne pas oublier l'appel done() à la fin !
```
from turtle import *

...
```
Réutiliser le code de la question 2 (donc avec une boucle) pour améliorer la définition de la fonction carre(cote, couleur), faite au TP précédent :
```
from turtle import *

def carre(cote, couleur):
    ...
```
En appelant la fonction carre(cote, couleur), tracer 4 carrés de 100 pixels de côté, rouges, côte à côte (collés) grâce à une boucle bornée.
```
from turtle import *

...
```
Tracer encore 4 carrés côte à côte, mais espacés de 50 pixels. On pourra utiliser soit la fonction forward, soit la fonction goto. On rappelle que up() et down() permettent de lever (pour ne pas tracer) et de baisser (pour tracer) la tortue.
```
from turtle import *

...
```
Utiliser une boucle bornée pour créer 4 cercles grâce à la fonction circle(rayon), de rayon 50px et espacés de 50px.
```
from turtle import *

...
```
Utiliser une boucle bornée pour créer 4 cercles, respectivement de rayon 50, 40, 30 et 20px et espacés de 10px.
```
from turtle import *

...
```
On veut maintenant dessiner 4 carrés espacés de 10px sur une ligne, puis 3 autres lignes de carrés dessinées en-dessous, disposés de la même façon.
Ecrire le programme correspondant, utilisant 2 boucles imbriquées et la fonction carre.
```
from turtle import *

...
```

Pour aller plus loin...
Ecrire une fonction permettant de choisir le nombre de lignes et le nombre de colonnes de carrés que l'on veut dessiner.

from turtle import *

...

Ne pas oublier d'enregistrer votre travail en cliquant sur la disquette en haut à gauche !

TP : Boucles bornées et fonctions¶

Pour toutes les questions de ce TP, on utilisera une boucle bornée.

Ecrire une fonction somme1() ne prenant pas de paramètre, et renvoyant la somme des entiers de 1 à 100 compris.
Ecrire une fonction somme2() ne prenant pas de paramètre, et renvoyant la somme des entiers pairs de 2 à 100 compris.
Ecrire une fonction somme3(n) prenant un entier n en paramètre, et renvoyant la somme des entiers de 1 à n compris.
Ecrire une fonction somme4(n) prenant un entier n en paramètre, et renvoyant la somme des entiers impairs de 1 à n compris.
Ecrire une fonction multiplication(a, b) prenant en paramètres deux entiers a et b et renvoyant la multiplication de a par b sans utiliser l'opérateur *, mais uniquement les opérateurs + et -.

Aide : distinguer le cas où a et b sont positifs, du cas où un des deux est positif, du cas où les 2 sont négatifs.
Ecrire une fonction table(n) prenant en paramètre un entier n pouvant valoir de 2 à 9 et affichant sa table de multiplication.
Ecrire une fonction tables_multiplication() affichant toutes les tables de multiplication des chiffres de 2 à 9. On utilisera 2 boucles bornées imbriquées.

Itération	`i`	`2*i`
1
2