## Les boucles *Tant que* (avec `while`)
Ce type de boucle est adapté quand nous ne savons pas à l'avance combien de fois les instructions doivent être répétées.
**Exemple 1**
Demandons à un utilisateur d'entrer des prénoms et arrêtons-nous quand le prénom est "Bébert". Lisez puis testez ceci dans l'éditeur Python :
```python
prenom = "Hubert" # ou n'importe quel texte autre que "Bébert"
while prenom != "Bébert": # tant que le prenom n'est pas "Bébert"
prenom = input() # demander à l'utilisateur un autre prénom
print("Bonjour", prenom)
print("Ah non, pas Bébert !")
```
La boucle se lit ici : tant que la variable `prenom` ne contient pas la valeur "Bébert", demander (`input`) une nouvelle valeur, l'affecter à `prenom` et afficher "Bonjour"
suivi de la valeur entrée.
La boucle *Tant que* (`while`) exécute des instructions tant qu'une condition est vérifiée.
Une condition de `while` s'écrit comme une condition de `if`.
La condition doit comporter un élément variable (une variable ou résultat d'une fonction faisant appel au hasard ou...). En effet, observez que :
while 1 < 2:
...
comme `1 < 2` est toujours vrai, cette boucle ne s'arrêtera jamais (boucle infinie).
while 1 == 2:
...
comme `1 == 2` est toujours faux, cette boucle ne s'exécutera pas et donc ne sert à rien.
while a > 2:
...
ici la boucle sera exécutée tant que `a > 2`.
Il faut bien sûr :
* que la variable utilisée dans la condition (ici `a`) ait été définie avant la boucle...
* que la condition finisse par être fausse pour sortir de la boucle (ici, il faut que `a` change de valeur et finisse par être inférieure ou égale à 2).
Que se passe-t-il :
* si vous supprimez la première ligne ?
* si vous mettez `prenom = "Bébert"` à la place de `prenom = "Hubert"` ?
Il est toujours possible de remplacer une boucle `for` par une boucle `while`.
Par exemple :
```python
for n in range(100):
print("Je ne me laisserai pas aller à la facilité")
```
peut s'écrire :
```python
nb_copie = 0
while nb_copie < 100:
print("Je ne me laisserai pas aller à la facilité")
nb_copie = nb_copie + 1
```
L'inverse n'est pas vrai, il suffit de réfléchir à l'exemple 1 ci-dessus, non réalisable avec un `for` (nous ne savons pas combien de prénoms l'utilisateur va entrer avant d'entrer "Bébert"...).
On dit que la boucle `for` est une boucle bornée et que la boucle `while` est une boucle non bornée.
Il est fréquent d'utiliser une variable qui va permettre à la boucle de s'interrompre mais d'autres variables peuvent apparaître comme *accumulateurs*, comme dans l'exemple suivant :
**Exemple 2**
Faisons une division entière avec des soustractions ; par exemple combien y a-t-il de 7 dans 61 ? L'idée est ici de retirer des 7 du nombre 61 tant que c'est possible (tant que le résultat dépasse 7).
```python
nb_sept = 0
nombre = 61
reste = nombre
while reste >= 7: # je peux encore retirer un 7
nb_sept = nb_sept + 1 # ou nb_sept += 1
reste = reste - 7 # je retire un 7 du reste
print("Il y a", nb_sept, "sept dans", nombre, "et il reste", reste)
```
Prenez le temps de regarder comment ce programme fonctionne :
Si vous avez fini les cinq exercices ci-dessus :
Exercice 6 : multiplication "russe".
# Placez votre code ici puis cliquez sur le bouton "Exécuter".
La syntaxe générale est :
début du programme
while condition: bloc d’instructions à exécuter tant que la condition est vérifiée
suite du programme
```mermaid
graph LR
A[début]-->B{while}
B-->|condition vérifiée| C[instructions dans le while]
B-->|condition non vérifiée| D[suite du programme]
C-->|retour au début du while|B
```
Remarquez les points communs avec `def`, `if` et `for` :
* le `:` à la fin de la ligne du `while` ;
* le bloc d’instructions à repéter est indenté.
Enfin, remarquez qu'il y a trois points essentiels pour créer une boucle `while` :
* Initialisation(s) : avant la boucle la (ou les) variable(s) utilisée(s) dans la condition [doivent être initialisée(s)](red).
* Condition : bien la définir. En particulier, il est préférable qu'elle devienne fausse à un certain moment !
* Modification(s) : la (ou les) variable(s) utilisée(s) dans la condition [doivent être modifiée(s)](red) (sans quoi, la boucle sera infinie).
La commande `break` permet de sortir définitivement d'une boucle. En général, il est conseillé de se passer de cette commande mais elle peut servir dans de rares occasions.
Exemple d'utilisation (non pertinente):
```python
n = 0
while True: # boucle infinie
if n == 10:
break # sortir de la boucle quand n vaut 10
n = n + 1 # instruction non exécutée si n vaut 10
print("n vaut", n)
```
La commande `continue` permet de sortir de l'itération actuelle et de passer à l'itération suivante.
Testez l'exemple suivant :
```python
n = 0
while n < 10:
n = n + 1
if n == 5:
continue # passer à l'itération suivante si n vaut 5
print("n vaut", n) # instruction non exécutée si n vaut 5
```
Petite remarque au passage : vous avez vu que la dernière ligne dit que n vaut 10, c'est pourquoi il n'y a plus d'autre itération.