Programmation Python/Instructions répétitives
L'instruction "while"
[modifier | modifier le wikicode]Cette instruction est une boucle, c'est-à-dire qu'elle permet de répéter plusieurs fois un bloc d'instructions (en boucle).
"while" exécute des commandes tant qu'une ou plusieurs conditions sont vraies.
while condition:
commandes
par exemple :
i = 0
while i < 5:
i = i + 1
print(i)
donne à l'exécution :
1 2 3 4 5
En effet, la seconde ligne indique à Python qu'il lui faut répéter continuellement le bloc d'instructions qui suit, tant que le contenu de la variable "a" reste inférieur à "5".
Comme l'instruction "if", l'instruction "while" amorce une instruction composée. Le double point à la fin de la ligne introduit le bloc d'instructions à répéter, lequel doit obligatoirement se trouver en retrait.
Nous avons ainsi construit notre première boucle de programmation, laquelle répète un certain nombre de fois le bloc d'instructions indentées. Voici comment cela fonctionne :
- Avec l'instruction "
while", Python commence par évaluer la validité de la condition fournie entre parenthèses (celles-ci sont optionnelles, nous ne les avons utilisées que pour clarifier notre explication).
- Si la condition se révèle fausse, alors tout le bloc qui suit est ignoré et l'exécution du programme se termine.
- Si la condition est vraie, alors Python exécute tout le bloc d'instructions constituant le corps de la boucle, c'est-à-dire :
- l'instruction
a = a + 1qui incrémente d'une unité le contenu de la variable "a" (ce qui signifie que l'on affecte à la variable "a" une nouvelle valeur, qui est égale à la valeur précédente augmentée d'une unité). - l'instruction "
print" qui affiche la valeur courante de la variable "a".
- l'instruction
- Lorsque ces deux instructions ont été exécutées, nous avons assisté à une première itération, et le programme boucle, c'est-à-dire que l'exécution reprend à la ligne contenant l'instruction "
while". La condition qui s'y trouve est à nouveau évaluée, et ainsi de suite.
Dans notre exemple, si la conditiona < 5est encore vraie, le corps de la boucle est exécuté une nouvelle fois et le bouclage se poursuit.
Remarques
[modifier | modifier le wikicode]- La variable évaluée dans la condition doit exister au préalable (il faut qu'on lui ait déjà affecté au moins une valeur).
- Si la condition est fausse au départ, le corps de la boucle n'est jamais exécuté.
- Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment (tout au moins tant que Python lui-même continue à fonctionner), en risquant de saturer les processeurs (si cela survient, presser CTRL + C pour annuler le lancement). Il faut donc veiller à ce que le corps de la boucle contienne au moins une instruction qui change la valeur d'une variable intervenant dans la condition évaluée par "
while", de manière à ce que cette condition puisse devenir fausse et donc que la boucle se termine.
Exemple de boucle infinie (à éviter) :
>>> n = 3
>>> while n < 5:
... print("hello !")
Exemple : élaboration d'une table de multiplication.
>>> a = 0
>>> while a < 12:
... a = a + 1
... print(a, a**2 , a**3)
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728
On obtient donc la liste des carrés et des cubes des nombres de 1 à 12.
Construction d'une suite mathématique
[modifier | modifier le wikicode]Le petit programme ci-dessous permet d'afficher les dix premiers termes d'une suite appelée « suite de Fibonacci ». Il s'agit d'une suite de nombres, dont chaque terme est égal à la somme des deux termes qui le précèdent. Analysez ce programme (qui utilise judicieusement l'affectation multiple). Décrivez le mieux possible le rôle de chacune des instructions.
>>> a, b, c = 1, 1, 1 >>> while c < 11 : ... print b, # print ( b , end=" " ) avec python3 ... a, b, c = b, a+b, c+1
Lorsque vous lancez l'exécution de ce programme, vous obtenez :
1 2 3 5 8 13 21 34 55 89
Les termes de la suite de Fibonacci sont affichés sur la même ligne. Vous obtenez ce résultat grâce à la virgule placée à la fin de la ligne qui contient l'instruction "print". Si vous supprimez cette virgule, les nombres seront affichés l'un en-dessous de l'autre.
Lorsque vous examinez un problème de cette nature, vous devez considérer les lignes d'instruction, bien entendu, mais surtout décortiquer les états successifs des différentes variables impliquées dans la boucle. Cela n'est pas toujours facile, loin de là. Pour vous aider à y voir plus clair, prenez la peine de dessiner sur papier une table d'états similaire à celle que nous reproduisons ci-dessous pour notre programme « suite de Fibonacci » :
| Variables | a | b | c |
| Valeurs initiales | 1 | 1 | 1 |
| Valeurs prises successivement, au cours des itérations | 1 2 3 5 … |
2 3 5 8 … |
2 3 4 5 … |
| Expression de remplacement | b | a+b | c+1 |
Dans une telle table, on effectue en quelque sorte « à la main » le travail de l'ordinateur, en indiquant ligne par ligne les valeurs que prendront chacune des variables au fur et à mesure des itérations successives. On commence par inscrire en haut du tableau les noms des variables concernées. Sur la ligne suivante, les valeurs initiales de ces variables (valeurs qu'elles possèdent avant le démarrage de la boucle). Enfin, tout en bas du tableau, les expressions utilisées dans la boucle pour modifier l'état de chaque variable à chaque itération.
On remplit alors quelques lignes correspondant aux premières itérations. Pour établir les valeurs d'une ligne, il suffit d'appliquer à celles de la ligne précédente, l'expression de remplacement qui se trouve en bas de chaque colonne. On vérifie ainsi que l'on obtient bien la suite recherchée. Si ce n'est pas le cas, il faut essayer d'autres expressions de remplacement.
Exercices
- Écrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7.
- Écrivez un programme qui affiche une table de conversion de sommes d'argent exprimées en euros, en dollars canadiens. La progression des sommes de la table sera « géométrique », comme dans l'exemple ci-dessous :
1 euro(s) = 1.65 dollar(s) 2 euro(s) = 3.30 dollar(s) 4 euro(s) = 6.60 dollar(s) 8 euro(s) = 13.20 dollar(s) etc. (S'arrêter à 16384 euros)
- Écrivez un programme qui affiche une suite de 12 nombres dont chaque terme soit égal au triple du terme précédent.
Solution
-
>>> c = 0 >>> while c < 20: ... c = c +1 ... print c, "x 7 =", c*7
ou encore :
>>> c = 1 >>> while c <= 20: ... print c, "x 7 =", c*7 ... c = c +1
-
>>> s = 1 >>> while s <= 16384: ... print s, "euro(s) =", s *1.65, "dollar(s)" ... s = s *2
-
>>> a, c = 1, 1 >>> while c < 13: ... print a, ... a, c = a *3, c+1
Exercices
- Ecrivez un programme qui calcule le volume d'un parallélépipède rectangle dont sont fournis au départ la largeur, la hauteur et la profondeur.
- Ecrivez un programme qui convertisse un nombre entier de secondes fourni au départ, en un nombre d'années, de mois, de jours, de minutes et de secondes.
(Utilisez l'opérateur modulo : %). - Ecrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7, en signalant au passage (à l'aide d'une astérisque) ceux qui sont des multiples de 3.
Exemple : 7 14 21 * 28 35 42 * 49 - Ecrivez un programme qui calcule les 50 premiers termes de la table de multiplication par 13, mais n'affiche que ceux qui sont des multiples de 7.
- Ecrivez un programme qui affiche la suite de symboles suivante :
* ** *** **** ***** ****** *******
Solution
- Réfléchissez !
-
# Le nombre de secondes est fourni au départ : # (un grand nombre s'impose !) nsd = 12345678912 # Nombre de secondes dans une journée : nspj = 3600 * 24 # Nombre de secondes dans un an (soit 365 jours - # on ne tiendra pas compte des années bissextiles) : nspa = nspj * 365 # Nombre de secondes dans un mois (en admettant # pour chaque mois une durée identique de 30 jours) : nspm = nspj * 30 # Nombre d'années contenues dans la durée fournie : na = nsd / nspa # division <entière> nsr = nsd % nspa # n. de sec. restantes # Nombre de mois restants : nmo = nsr / nspm # division <entière> nsr = nsr % nspm # n. de sec. restantes # Nombre de jours restants : nj = nsr / nspj # division <entière> nsr = nsr % nspj # n. de sec. restantes # Nombre d'heures restantes : nh = nsr / 3600 # division <entière> nsr = nsr % 3600 # n. de sec. restantes # Nombre de minutes restantes : nmi = nsr /60 # division <entière> nsr = nsr % 60 # n. de sec. restantes print "Nombre de secondes à convertir :", nsd print "Cette durée correspond à", na, "années de 365 jours, plus" print nmo, "mois de 30 jours,", print nj, "jours,", print nh, "heures,", print nmi, "minutes et", print nsr, "secondes."
-
# affichage des 20 premiers termes de la table par 7, # avec signalement des multiples de 3 : i = 1 # compteur : prendra successivement les valeurs de 1 à 20 while i < 21: # calcul du terme à afficher : t = i * 7 # affichage sans saut à la ligne (utilisation de la virgule) : print t, # ce terme est-il un multiple de 3 ? (utilisation de l'opérateur modulo) : if t % 3 == 0: print "*", # affichage d'une astérisque dans ce cas i = i + 1 # incrémentation du compteur dans tous les cas - Réfléchissez !
- Réfléchissez !
L'instruction "for"
[modifier | modifier le wikicode]La boucle "for" permet d'exécuter une itération un certain nombre de fois :
>>> for i in range(5):
... print(i)
0
1
2
3
4
Pour le "foreach" (répétition pour chaque élément d'un itérable) :
>>> for champ in ['champ1', 'champ2', 'champ3']:
... print(champ)
champ1
champ2
champ3
Pour avoir les clés avec les valeurs :
dict = {'key1': 'value1', 'key2': 'value2'}
for key in dict:
... print(key, '->', dict[key])
Les instructions "break", "continue"
[modifier | modifier le wikicode]L'instruction "break" permet d'arrêter une boucle avant sa fin. L'instruction "continue" est similaire, mais au lieu d'interrompre la boucle, elle permet de passer à l'itération suivante.
for i in range(5):
if i==3:
break
print i
affichera
0 1 2
tandis que
for i in range(5):
if i==3:
continue
print i
affichera
0 1 2 4