Découverte
Nous avons déjà vu dans un chapitre précédent que pour effectuer une répétition,
il suffisait d'utiliser une boucle répétitive for.
Cependant, pour utiliser cette instruction, il est nécessaire de connaître à l'avance le nombre de répétitions à effectuer.
Que faire lorsque l'on ne peut pas connaître ce nombre ?
Voilà l'intérêt de ce nouveau chapitre pour vous faire découvrir une nouvelle instruction, celle Tant que
qui s'écrit en langage Python while !
Un exemple introductif
On considère la course des 24 heures du Mans, une course automobile dans laquelle les pilotes se relaient pour effectuer
des tours de pistes pendant 24 heures. L'équipe de pilote gagnante est celle ayant parcouru la plus grande distance.
-
Une équipe de pilote peut-elle savoir à l'avance le nombre de tours qu'elle fera durant les 24 heures ?
-
Quelle est la condition d'arrêt de la course ?
Formalisation
Lorsque l’on doit dans un programme effectuer plusieurs fois la même tâche pendant un nombre inconnu
d'itérations (=répétitions),
on utilise une boucle répétitive conditionnelle, souvent notée Tant que
en pseudo-langage.
On formalise ce type de boucle ainsi :
Tant que condition vraie
faire tâche
Fin_Tant que
-
Il n'y a plus forcément de compteur permettant de compter le nombre de fois où
la boucle est effectuée. Si besoin, vous avez à créer une variable affectée à cette tâche.
-
On sait pas à l’avance combien de fois sera répétée la tâche.
-
Ce type d'écriture d'un programme s'appelle du pseudo-langage.
On peut modéliser les 24 heures du Mans par l'algorithme suivant en pseudo-langage :
Tant que le temps écoulé est inférieur à 24 heures
rouler un tour de piste supplémentaire
Fin_Tant que
afficher("Arrivée")
Voici un algotihme écrit en pseudo-langage :
Choisir une valeur entière positive N # correspond en langage Python à : int(input("N="))
Tant que N≥10 faire
N ← N-10 # correspond en langage Python à : N = N-10
Fin_Tant que
Afficher(N) # correspond en langage Python à : print(N)
-
Reproduire sur une feuille puis compléter ce tableau dans le cas où N=37 :
| Valeur stockée dans N |
Valeur de la condition N≥10 (Vraie ou fausse) |
action sur la boucle Tant que (début, poursuite, fin) |
affichage |
| 37 |
... |
... |
... |
| ... |
... |
... |
... |
| ... |
... |
... |
... |
| ... |
... |
... |
... |
-
Tester ce programme avec une autre valeur.
-
En comparant la valeur affichée avec celle saisie initialement, déterminer le rôle de cet algorithme.
Reproduire et compléter l'algorithme ci-contre afin qu'il affiche la plus petite valeur de l'entier N tel que la somme
S des N premiers entiers naturels non nuls dépasse 12 :
S ← 0 # correspond en langage Python à : S = 0
N ← 0 # correspond en langage Python à : S = 0
Tant que ................ faire
N ← N+1 # correspond en langage Python à : N = N+1
S ← ......
Fin_Tant que
Afficher(N) # correspond en langage Python à : print(N)
-
Reproduire et compléter le tableau pour en déduire la valeur de N affichée en sortie dans l'algorithme précédent.
| Valeur stockée dans N |
Valeur stockée dans S |
Valeur de la condition |
action sur la boucle Tant que (début, poursuite, arrêt) |
affichage |
| 0 |
0 |
... |
... |
... |
| ... |
... |
... |
... |
... |
| ... |
... |
... |
... |
... |
| ... |
... |
... |
... |
... |
| ... |
... |
... |
... |
... |
| ... |
... |
... |
... |
... |
-
Jusqu'à quel entier faut-il ajouter pour que la somme dépasse 12 pour la première fois ?
Boucle répétitive conditionnelle en langage Python : while
La structure while est l'implémentation en langage Python de la notion de boucle répétitive
conditionnelle Tant que.
Voici la structure en Python d'une telle boucle while
while condition:
instruction 1
instruction 2
...
Tant que la condition est vraie les instructions du bloc sont exécutées.
Dans cette structure, on ne connait pas à l'avance le nombre de répétitions.
Deux écueils à éviter :
-
Ne jamais entrer dans une boucle : si la condition au départ vaut False, la boucle while ne sera jamais exécutée.
-
Tourner indéfiniment : Si la condition ne change jamais de valeur, la boucle ne s'arrêtera pas et l'algorithme
restera bloqué sur le while.
Une balle part d'une hauteur de 2 mètres et perd 10% de sa hauteur à chaque rebond. On cherche le nombre de rebonds pour la balle atteigne un
maximum de 1,5 mètre de hauteur. Ce problème (on parle de problème de seuil) peut être traité en python par le script suivant :
hauteur = 2
rebond = 0
seuil = 1.5
while hauteur>seuil:
rebond = rebond+1
hauteur = hauteur*0.9
print(rebond)
-
Tester ce script
Vous pouvez visualiser les étapes de mise en oeuvre de ce programme en utilisant le lien suivant :
-
Modifier les valeurs pour que la balle démarre à une hauteur de 3 mètres et atteigne la hauteur de 2 mètres.
Une cuve d'eau à une contenance de 1000L.
-
En moyenne la cuve d'eau se remplis de 3L d'eau par jours.
Écrire une fonction remplir() qui renvoie le nombre jours qu'il faudra pour remplir la cuve.
-
Écrire une fonction remplir(quant) où quant est un entier correspondant au volume d'eau
arrivant dans la cuve par jours, qui renvoie le nombre jours qu'il faudra pour remplir la cuve.
On place 1000 euros sur un livret A. Le taux annuel de rémunération est 0,25%.
Écrire une fonction
doublement() qui renvoie le nombre d'année qu'il faut pour doubler la somme de 1000 euros.
exercice de renforcement
Arjuna souhaite travailler dans un centre d'arts martiaux quelques heures par semaine. À la suite d'un entretien, deux possibilités
de salaire s'offrent à lui :
-
Proposition 1 : toucher 8 euros de l'heure,
-
Proposition 2 : versement de 91€ en début de mois, puis toucher 5 € chaque heure travaillée.
-
Écrire une fonction prop1(h) qui renvoie le salaire de Arjuna après avoir travaillé h heures avec la proposition 1.
-
Écrire une fonction prop2(h) qui renvoie le salaire de Arjuna après avoir travaillé h heures avec la proposition 2.
-
Proposer une fonction choix() qui renvoie le nombre d'heures à partir duquel la proposition 1 est préférable pour Arjuna.
Lorsque l'utilisateur saisit une donnée, il peut être utile de vérifier qu'elle est conforme à ce qu'on attend de lui.
-
Proposer une fonction saisie() qui demande à l'utilisateur de rentrer un nombre positif et qui renvoie ce nombre.
-
Ecrire une fonction saisie2() qui demande à l'utilisateur de saisir un nouveau nombre si le nombre entré est négatif qui renvoie le nombre.
On utilisera la fonction saisie().
-
Écrire une fonction repeter_lim(times) qui affiche le message : "Bravo tu es capable de choisir un nombre positif" si on propose un nombre positif en moins de times fois et qui affiche "Quel idiot ! tu ne sais pas ce qu'est un nombre positif !".
On utilisera la fonction saisie()
Une banque propose à ses clients une carte de crédit. Chaque mois elle prélève le minimum entre 3 euros et 1%
du montant des transactions effectuées par cette carte de crédit. Dans le cas, où il ne reste plus assez sur le compte
pour payer les frais, elle ne prélève que le restant sur le compte.
-
Proposer une fonction minimum qui renvoie le minimum des deux nombres entrés comme
arguments.
-
Proposer une fonction frais qui prend en paramètres deux nombres réels : la somme sur
le compte et le montant des transactions effectués par carte bancaire et qui renvoie les frais bancaires
qui seront prélevés.
-
Un client impécunieux possède 5073.68€ sur son compte. Il possède une carte de crédit avec laquelle il retire chaque mois
200€. Sachant qu'il ne remet pas d'argent sur son compte, pendant combien de temps pourra-t-il prélever ainsi
de l'argent sur son compte.
Pour accéder au code de la correction : lien
Votre enseignant vous exploite : il vous demande de créer un programme qui lui renverra la moyenne des notes saisies.
Pour cela, il vous donne le cahier des charges suivant :
-
Créer une fonction continuer, sans paramètre d'entrée qui demande à l'utilisateur s'il veut poursuivre ou non la saisie
de notes et qui renvie un booléen True en cas de poursuite et False sinon.
-
Créer une fonction moyenne qui calcule la nouvelle moyenne liée à l'ajout d'une note.
-
Créer dans le programme principal une fonction main qui conduit à demander une nouvelle note et à calculer la moyenne
obtenue alors jusqu'à ce que l'utilisateur décide d'arrêter la saisie.
-
Proposer une fonction continuer qui répond au cahier des charges. Faire en sorte que la casse (=minuscule ou majuscule) ne
soit pas un problème pour la saisie, par exemple en utilisant ma méthode upper.
"mélanGes".upper() renvoie 'MÉLANGES'.
-
Tester la fonction continuer créée.
-
Proposer une fonction moyenne qui répond au cahier des charges. Cette fonction aura trois paramètres :
moy un flottant qui correspond à la moyenne pour l'instant obtenue,nb_notes un entier qui correspond au nombre de notes déjà pris en compte dans la moyenne moy,new_note un flottant qui correspond à la nouvelle note à prendre en compte pour la moyenne.
Cette fonction renverra la moyenne de l'ensemble des notes saisies (en comptant aussi la dernière).
Aide mathématique :
On considère deux ensembles de notes A et B de moyenne respective $moy_A$ et $moy_B$ comprenant respectivement $nb_A$ et $nb_B$ notes.
La moyenne des notes formant la réunion de ces deux ensembles est doné par la formule :
$$ moyenne = \frac{moy_A \times nb_A + moy_B \times nb_B}{nb_A + nb_B}$$.
-
Tester la fonction moyenne créée.
-
Proposer une fonction main qui répond au cahier des charges. Cette fonction fera appel aux deux fonctions
continuer et moyenne et n'aura pas de paramètre ; elle renverra la moyenne de toutes les notes successivement
saisies.
-
Tester votre programme principal, par exemple en saisissant successivement les valeurs 10, 19 et 13.
Pour accéder au code de la correction : lien
Exercices de renforcement
Chaque année la consommation énergétique d'un data center est estimée augmenter de 8 %.
Déterminer le nombre d'années nécessaires au doublement de la consommation énegétique de ce data center.
Le résultat ne dépend pas de la consommation énergétique actuelle de ce data center.
Pour accéder au code de la correction : lien