CHAPITRE 2 : LES BOUCLES
LES LANGAGES DE
PROGRAMMATION :
LE PYTHON
Ce chapitre revient sur les boucles et donc sur la manière de répéter des instructions.
Pour afficher les nombres de 0 à 9, c'est-à-dire de 0 (inclus) à 10 (non inclus) vous utilisez actuellement le code suivant :
nombre = 0
for loop in range(10):
print(nombre)
nombre = nombre + 1 Eh bien, sachez qu'il est également possible de faire ainsi :
for loop in range(10):
print(loop)
En effet, loop est en fait une variable ! On peut donc l'utiliser comme n'importe quelle
variable, en particulier pour l'afficher. On peut également utiliser un autre nom de variable (loop n'étant pas très clair). Ainsi on écrira plutôt :
for nombre in range(10):
print(nombre)
La boucle for
3
En pratique range(10) se comporte comme la suite de valeurs 0, 1, ..., 9 et ce code revient à dire :
Pour chaque valeur dans [0, 1, ..., 9] affecter cette valeur à la variable "nombre" et Afficher la variable "nombre"
Le fonctionnement de range() est en réalité un peu plus complexe que cela et sous sa forme générale, il s'utilise ainsi :
for nombre in range(<debut>, <fin>, <saut>):
...
ce qui va faire prendre à la variable nombre toutes les valeurs entre <debut> (inclus) et
<fin> (non inclus) en faisant des sauts de <saut> à chaque fois.
Quelques exemples :
for nombre in range(0, 10, 1):
print(nombre, end = " ")
↳
0 1 2 3 4 5 6 7 8 9
On va donc de 0 (inclus) à 10 (non inclus, c'est- à-dire 9 inclus) en faisant "+1" entre chaque valeur.
for nombre in range(10, 21, 1):
print(nombre)
↳
10 11 12 13 14 15 16 17 18 19 20
On va donc de 10 (inclus) à 21 (non inclus, c'est-à-dire 20 inclus) en faisant "+1"
entre chaque valeur.
for nombre in range(100, 121, 2):
print(nombre)
↳
100 102 104 106 108 110 112 114 116 118 120
On va donc de 100 (inclus) à 121 (non inclus, c'est-à-dire 120 inclus) en faisant "+2" entre chaque valeur.
On veut afficher des nombres de manière décroissante, donc le "saut" est négatif for nombre in range(20, -21, -5):
print(nombre)
↳
20 15 10 5 0 -5 -10 -15 -20
On va donc de 20 (inclus) à -21 (non inclus, c'est-à-dire -20 inclus) en faisant "-5" entre chaque valeur.
On commence donc par la valeur de début et tant qu'on est strictement plus petit (si le saut est positif) / grand (si le saut est négatif) que la valeur de fin, on passe d'une valeur à la valeur suivante en faisant le "saut" indiqué.
5
Saut non précisé
S'il n'est pas précisé, le "saut" vaut 1, on peut donc écrire
Formes réduites
for nombre in range(100, 201):
...
à la place de
for nombre in range(100, 201,1):
...
Si on à un "début" égal à 0 et un "saut" égal à 1, alors il existe une écriture plus courte.
Ainsi :
Début et saut non précisé
for nombre in range(0, 10, 1):
...
peut être remplacé par
for nombre in range(10):
...
C'est la forme que vous connaissiez et que vous utilisiez jusqu'à présent. Elle permettait bien de répéter 10 fois une suite d'instruction puisque range(10) contient les valeurs 0, 1, ..., 9 soit 10 valeurs au total.
En conclusion
La boucle for permet de "parcourir" ce qu'on appelle un itérable.
Un itérable correspond à une suite de valeur (numérique ou non). On peut donc examiner chaque valeur que contient l'itérable.
Par exemple, l'expression range(10) créé un itérable contenant les valeurs
0,1,2,3,4,5,6,7,8,9, la boucle for permet de parcourir cet itérable en utilisant une variable (loop ou nombre ou ce que vous voulez) celle-ci prend chaque valeur de l'itérable.
On verra que la boucle for permet de parcourir autre chose que des plages de valeurs définies par l'expression range. Ainsi, elle permet le parcours des chaines de caractères, de listes, de tuples... nous y reviendrons.
Exercice 1 : Ecrivez le programme pour afficher le calendrier des 31 jours de janvier.
On veut l'affichage suivant : 1 janvier
2 janvier 3 janvier ..
31 janvier
7
Exercice 2 : Ecrire un programme qui affiche le calendrier pour une année bissextile entière. Votre programme doit tenir compte des mois en 31 , 30 et 29 jours.
On affichera le calendrier avec des mois en chiffre. ex : 16/10 ; 28/2
Je veux écrire un programme qui calcule le nombre de fois qu'il faut diviser par deux un nombre réel x ( avec x >=1) pour obtenir un nombre inférieur ou égal à 1.
Ce programme correspond en fait au calcul du logarithme entier.
Exemple, je divise 60 000 seize fois par deux pour obtenir 0.915.
Le logarithme entier de 60 000 est donc 16
Ce programme est donc formé d'une boucle qui divise x par 2 plusieurs fois, jusqu'à obtenir un nombre inférieur ou égal à 1.
Dans le même temps, il faut compter le nombre de fois qu'est effectué la division, et donc utiliser une variable n à laquelle on ajoute 1 à chaque division effectuée.
Cette boucle est très différente de la précédente, puisqu'on ne peut pas savoir
combien de fois on doit faire de division, ainsi on ne sait pas au début de l'exécution de cette boucle, le nombre de fois que sera répété le corps de la boucle.
Impossible de d'écrire ce programme avec une boucle for.
C'est pourquoi, il existe une 2ème forme de boucle : la boucle while.
La boucle while : une répétition conditionnée
Faire la même chose plusieurs fois : le « tant que »
On a parfois besoin de répéter certaines instructions jusqu'à ce qu'un certain changement ce soit produit. Par exemple, demander un mot de passe tant que l'utilisateur n'a pas donné le bon, ou diviser par 2 un nombre tant que le résultat n'est pas inférieur à 1.
On a ici utilisé dans la phrase le terme « tant que », ce qui signifie qu'on a bien une condition pour savoir quand s'arrêter. On ne peut pas utiliser notre boucle « répéter » habituelle, car on ne sait pas combien de fois l'utilisateur va se tromper ! ou combien de fois il faut diviser par 2.
On va donc faire intervenir une autre boucle : la boucle « tant que ».
Elle se nomme while dans les langages de programmation (traduction en anglais de « tant que »).
x=float(input("Entrer un nombre")) nbDivisPar2=0
while x>1.0 : x=x/2.0
nbDivisPar2 = nbDivisPar2+1 print(nbDivisPar2)
Le programme du calcul du logarithme entier est alors le suivant :
On remarque comme pour la boucle for, une indentation qui permet de savoir quelles instructions appartiennent à la boucle et les :
x=float(input("Entrer un nombre")) nbDivisPar2=0
while x>1.0 : x=x/2.0
nbDivisPar2 = nbDivisPar2+1 print(nbDivisPar2)
On peut schématiser ainsi le déroulement de ce programme pour le nombre 60 000 x = 60000
nbDivisPar2=0 while x>1.0 :
x=x/2.0
nbDivisPar2 = nbDivisPar2+1
x est supérieur à 1, on entre dans la boucle while x est-il encore supérieur à 1 ?
si oui faire
recommencer si non
faire
print(nbDivisPar2)
Exercice 3 : Ecrivez le programme qui demande à un utilisateur de saisir un mot de passe sous forme d'un entier tant qu'il n'a pas indiqué le mot de passe correct ( qui est : 123456).
Il est bien sûr possible d'utiliser des opérateurs booléens pour combiner des conditions et les valeurs booléennes sont également utilisables.
Voici quelques extraits de code à titre d'exemple : while True:
print("J'attends")
while motDePasse != secret or âgePersonne <= 3:
print("Accès refusé : mauvais mot de passe ou personne trop jeune") âgePersonne = int(input())
motDePasse = int(input())
while nbPersonnes <= nbMax and température <= 45:
print("Portes ouvertes")
nbPersonnes = nbPersonnes + 1 température = int(input())
Le premier de ces trois exemples est ce qu'on appelle une « boucle infinie », c'est-à- dire que le programme ne s'arrête jamais : comme True est toujours vrai, on ne quitte jamais la boucle.
Dans un code utilisant une boucle « tant que », si on utilise une mauvaise condition, il est possible que le programme ne s'arrête jamais.
Par exemple :
valeur 1
Tant que valeur <= 10 faire valeur valeur - 1
Ici, on a mis valeur - 1 au lieu de valeur + 1 ; du coup, la variable valeur ne fait que diminuer au lieu d'augmenter. Elle ne sera donc jamais plus grande que 10 et le programme ne s'arrêtera jamais
Si on connaît à l'avance le nombre de répétitions à effectuer, la boucle for est toute indiquée.
A l'inverse, si la décision d'arrêter la boucle ne peut s'effectuer que par un test, c'est la boucle while qu'il faut choisir.
Il existe une instruction ‘break’ pour forcer la sortie d’une boucle while mais son utilisation dans le cadre de la spécialité NSI est strictement interdite !
Un réflexion appropriée permet toujours de sortir d’un boucle avec élégance, dans le respect des normes de ‘bonne programmation’, sans utiliser d’instruction brutale…
Avec la boucle while apparaît donc un nouveau comportement possible pour les programmes : la non-terminaison.
Attention à bien réfléchir à la condition de terminaison de la boucle while
Exercice 4 : Afin de pouvoir mieux combattre les différentes épidémies, parfois très graves, qui se développent régulièrement dans la région, le département de
médecine de l'université a lancé une grande étude. En particulier, les chercheurs s'intéressent à la vitesse de propagation d'une épidémie et donc à la vitesse à laquelle des mesures sanitaires doivent être mises en place.
Votre programme doit d'abord lire un entier, la population totale de la ville. Sachant qu'une personne était malade au jour 1 et que chaque malade contamine deux
nouvelles personnes le jour suivant (et chacun des jours qui suivent), vous devez calculer à partir de quel jour toute la population de la ville sera malade.
Exemple 1 entrée : 3
sortie : 2
Exemple 2 entrée : 10
sortie : 4
On a 1 malade le premier jour, donc 2 nouveaux malades le second jour, soit un total de 3 malades. On a donc 6 nouveaux malades au troisième jour, soit un total de 9 malades. On a donc 18 nouveaux malades au quatrième jour, soit…
Exercice 5 : Toutes les dépenses de l'année ont été enregistrées et classées
dans une multitude de dossiers et il faut maintenant calculer la somme de toutes ces dépenses. Mais personne ne sait exactement combien de dépenses
différentes ont été effectuées durant l'année écoulée !
Votre programme devra lire une suite d'entiers positifs et afficher leur somme.
On ne sait pas combien il y aura d'entiers, mais la suite se termine toujours par la valeur -1 (qui n'est pas une dépense, juste un marqueur de fin).
Exemple 1 entrée : 1000 2000 500 -1 sortie : 3500
Exemple 2 entrée : -1
sortie : 0
Exercice 6 : Les habitants adorent les constructions en forme de pyramide ; de nombreux bâtiments officiels ont d'ailleurs cette forme. Pour fêter les 150 ans de la construction de la ville, le gouverneur a demandé la construction d'une grande et majestueuse pyramide à l'entrée de la ville. Malheureusement, en ces périodes de rigueur budgétaire, il y a peu d'argent pour ce projet. Les architectes souhaitent cependant construire la plus grande pyramide possible étant donné le budget prévu.
Votre programme doit d'abord lire un entier : le nombre maximum de pierres dont pourra être composée la pyramide. Il devra ensuite calculer et afficher un entier : la hauteur de la plus grande pyramide qui pourra être construite, ainsi que le nombre de pierres qui sera nécessaire.
Exemple 1 entrée : 20
sortie : 3
14
Exemple 2 entrée : 26042 sortie : 42 25585
