![](\"http://fsincere.free.fr/isn/python/picto/python_while.png\")
L’exécution d’un programme implique souvent la réalisation d’un grand nombre d'instructions. Cependant, un programme dont l'exécution implique
la réalisation d’un million d'opérations n’est généralement pas constitué d’un million de lignes.
On aura plus communément un programme de taille modeste, dont certains fragments sont exécutés un grand nombre de fois. Les boucles bornées présentées ici sont l’un des moyens de réaliser de telles répétitions.
for i in range(10) :
print(\"Nsi\")
"},{"text":"Si vous avez réalisé l'activité demandée, le bouton suivant apparaîtra en bas à droite pour réaliser l'étape d'après."}],[{"text":"On souhaite écrire un programme dessinant une spirale ayant l’allure suivante, avec un nombre de tours défini par l'utilisateur.
Pour être facilement dessinée et néanmoins harmonieuse, cette spirale est constitnée de demi-cercles dont les dimensions augmentent régulièrement à chaque demi-cercle à une épaisseur de un supérieure à l'épaisseur du précédent et un diamètre qui est le carré de cette valeur.
Cette méthode de construction étant connue, on peut facilement écrire à l’aide des instructions Turtle un programme effectuant un nombre de tours
fixé et pas trop grand.
import turtle
turtle.width(2)
turtle.circle(4, 180)
turtle.width(3)
turtle.circle(9, 180)
turtle.width(4)
turtle.circle(16, 180)
turtle.width(5)
turtle.circle(25, 180)
Ecrire et tester le programme dans l'IDLE de Python et mettre le résultat ci-dessous.
On voit que le le programme enchaîne quatre demi-cercles, c’est-à-dire deux tours complets. On peut aisément imaginer des variantes de ce programme traçant 3, ou 6, ou même 1001 tours.
Pour autant, on ne souhaite pas nécessairement les écrire. Qui plus est, rien ne nous permet dans ce qui a déjà été vu d'écrire un unique
programme demandant à l'utilisateur combien de tours il compte effectuer
et réalisant le tracé correspondant.
Les boucles bornées vues dans cette séquence, aussi appelées boucles for, répondent à ce double problème d'écriture condensée d’instructions répétitives et de sélection du nombre de répétitions à effectuer.
Mettre le résultat ici (code et figure).
Répétition d’une instruction
Pour exécuter trois fois la même instruction, on avait jusqu'ici la possibilité de recopier cette instruction trois fois à la suite l’une de l’autre.
print(\"A\")
print(\"A\")
print(\"A\")
Cette solution n’est pas raisonnable si le nombre de répétitions est important. De plus, elle n’est envisageable que si l'on connaît le nombre de
répétitions lors de l'écriture du programme. Si par exemple le nombre de répétitions est demandé à l'utilisateur, avec input, alors il devient impossible d'écrire un programme qui répétera notre instruction d’affichage ce nombre-là de fois.
Python, comme de nombreux langages de programmation, propose une instruction appelée « boucle for » permettant de gérer cette répétition.
En voici la forme la plus simple.
for _ in range(3): print(\"A\")
Le caractère souligné (_) fait partie de la construction. On indique entre parenthèses après range un nombre de répétitions à effectuer, chaque répétition étant appelée un tour.
L'instruction à répéter plusieurs fois est écrite après le symbole « : » (deux-points).
On l’appelle le corps de la boucle.
Mettre le résultat ici (code et figure).
Le nombre de tours peut être donné par
une expression arithmétique dont le résultat est calculé au préalable.
En particulier, cette expression peut dépendre d’une variable. Le programme suivant, par exemple, récupère un nombre n saisi par l’utilisateur puis affiche un nombre de lignes égal à deux fois ce nombre n.
n = int(inputO)
for __in range(2 * n): print (\"A\")
Mettre le résultat ici (code et figure).
Erreurs. Le nombre de tours de boucle doit impérativement être entier.
Tester le code suivant et conclure.
for _ in range(1.5): print (\"A\")
Il est tout à fait possible de prescrire un nombre de tours négatif.
On en aura dans ce cas zéro. Ainsi le programme suivant ne génère pas d'erreur, mais n'affiche rien non plus.
for _ in range(-12): print (\"A\")
Enfin, la présence du symbole « : » entre la déclaration des répétitions et l'instruction à répéter est indispensable.
Tester et écrire le code ci-dessous.
for _ in range(3) print(\"A\")
La répétition n’est pas nécessairement limitée à une instruction isolée, mais peut toucher une séquence arbitraire.
import turtle
from random import randint
x = randint(-100, 100)
y = randint(-100, 100)
turtle.goto(x, y)
x = randint(-100, 100)
y = randint(-100, 100)
turtle.goto(x, y)
x = randint(-100, 100)
y = randint(-100, 100)
turtle.goto(x, y)
Pour cela les instructions formant le corps de la boucle doivent être regroupées en un bloc, c'est-à-dire une suite de lignes en retrait du même nombre d’espaces. Ce nombre peut être arbitraire, mais l'usage est d'utiliser quatre espaces.
Le code suivant trace donc comme le précédent une
ligne brisée aléatoire en trois parties.
for __in range(3):
x = randint(-100, 100)
y = randint(-100, 100)
turtle.goto(x, y)
Ainsi en Python, l’indentation du code, c’est-à-dire les passages à la ligne et les retraits de chaque ligne, joue un rôle dans la signification du programme.
En particulier, une instruction supplémentaire qui ne serait plus alignée avec
le bloc formant le corps de la boucle, mais avec le for, ne serait exécutée qu’une seule fois, après que tous les tours ont été effectués.
for _ in range(3):
print(\"A\")
print(\"B\")
print(\"C\")
Le code suivant
demande donc d’abord à l'utilisateur de saisir un nombre n de segments
à tracer, trace ensuite n — 1 segments aléatoires, et enfin trace un dernier
segment qui ferme la figure en revenant au centre.
import turtle
from random import randint
n = int(input(\"Combien de segments ? \"))
for __in range(n-1):
x = randint(-100, 100)
y = randint(-100, 100)
turtle.goto(x, y)
turtle.goto(0, 0)
Les blocs peuvent être composés avec toutes les instructions Python, et notamment comme ici avec des instructions Turtle ou des affectations.
Tester et mettre le résultat ici (code et figure).
Dans les boucles bornées, il est possible d'introduire une nouvelle variable accessible à l’intérieur du corps de boucle et dont la valeur donne le numéro du tour en cours.
for i in range(10): print (i)
On appelle cette variable spéciale l'indice de boucle ou le compteur de boucle.
Attention aux erreurs d'indentation avec les boucles :
Corriger les programme ci-dessous pour afficher la table de 7 en expliquant l'erreur.
for i in range(10):
k = i * 7
print(i,\"*7 = \", k)
for i in range(10):
k = i * 7
print(i,\"*7 = \", k)
Mettre le résultat ici (code et figure).
Nous avons maintenant tous les ingrédients pour écrire un programme traçant une spirale avec un nombre de tours arbitraire.
from turtle import *
n = int(input(\"Combien de tours de spirale ? \"))
for i in range(2 * n):
width(i)
circle(i * i, 180)
Après inclusion des instructions de Turtle ce programme demande à l’utilisateur un nombre n de tours de spirale à tracer. Une boucle est ensuite
chargée de tracer chacun des demi-cercles de la spirale. Chaque tour de spirale étant formé par deux demi-cercles cette boucle est exécutée 2 * n fois.
L'indice de boucle i est de plus utilisé pour déterminer l’épaisseur du trait
et le rayon du demi-cercle tracé lors de ce tour de boucle.
Mettre le résultat ici (code et figure).
Les blocs peuvent être composés avec toutes les instructions de Python, et notamment avec les affectations.
On peut ainsi à chaque tour de boucle
récupérer de nouvelles entrées de l’utilisateur, successivement affectées aux mêmes variables x et y et remplaçant les éventuelles valeurs précédentes.
from turtle import *
n = int(input(\"Combien de segments ? \"))
for _ in range(n):
x = int(input (\"Entrer l’abscisse : \"))
y = int(input(\"Entrer l’ordonnée : \"))
goto(x, y)
Plutôt que de redonner à chaque tour une nouvelle valeur à à des variables x et y, on peut aussi lors d’un tour de boucle mettre à jour la valeur d’une variable, en repartant de la valeur qui avait été obtenue au tour
précédent. Cette variable dont la valeur progresse à chaque tour de boucle est appelée un accumulateur.
a = 1
for _ in range(4):
a=a+2
print (a)
Le code précédent est équivalent au programme déplié suivant.
a = 1
a= a +2
a = a +2
a = a +2
a = a +2
print(a)
Tous deux affichent 9 après avoir successivement donné à la variable a les valeurs 1, 3, 5, 7 et 9.
Mettre le résultat ici (code et figure).
Les accumulateurs sont un bon outil dès lors qu’un programme effectue un grand calcul, qui progresse un petit peu à chaque tour de boucle.
Pour calculer la moyenne des notes de n élèves par exemple on a besoin de toutes les additionner. Cette addition peut être faite note par note, en faisant évo-
luer un accumulateur. Ainsi le programme 3 effectue-t-il la moyenne de n notes fournies une à une par l'utilisateur.
Ce programme demande d’abord
à l'utilisateur le nombre n de notes qui vont être saisies et initialise à 0 un accumulateur grâce auquel sera calculée la somme des notes saisies.
Une boucle exécutée n fois va ensuite demander à l’utilisateur de saisir chacune des n notes et l’ajouter à l’accumulateur contenant la somme des notes saisies jusque-là.
Enfin, la moyenne est obtenue en divisant la somme obtenue par le nombre de notes.
.
n = int(input(\"Entrer le nombre d’élèves : \"))
somme = 0
for __ in range(n):
k = int(input('\"Entrer une note : \"))
somme = somme + k
moyenne = somme / n
print (\"La moyenne est\", moyenne)
Mettre le résultat ici (code et figure).
Les instructions du corps d’une boucle sont susceptibles d’être exécutées plus d’une fois. Cela se traduit par autant de lignes dans un tableau représentant l'exécution. Voici par exemple un programme qui calcule la somme des carrés des n premiers entiers 0,1,...,n—1,le nombre.
n étant fourni par l'utilisateur.
s = 0
n = int(input(\"Combien d’entiers 7? \"))
for i in range(n+1):
z= i*i
s=s+z
print (\"Somme des carrés :\", s)
Ecrire et tester le code pour n = 6.
Compléter le tableau ci-dessus en indiquant la valeur de z et de s à chaque tour de boucle.
On voit bien que la variable s accumule la somme des carrés.
Mettre le résultat ici (code et figure).
| tour | z (carré) | s (somme) |
| 0 | 0 | 0 |
| 1 | 1 | 1 |
| 2 | 4 | 5 |
| 3 | ||
| 4 | ||
| 5 | ||
| 5 |
Erreurs. Une variable utilisée comme accumulateur dans une boucle doit être initialisée avant la boucle, Un code sans initialisation comme le suivant est erroné.
for __in range(4):
a=a+2
Un code dans lequel l’initialisation est incluse dans la boucle n’empéchera pas l'exécution du programme, mais sera généralement une erreur se manifestant par un résultat inattendu. Ainsi, le code suivant réinitia-
lise la valeur de a à 1 à chaque tour, et n’affichera que 3 au terme de son exécution.
for __ in range(4):
a = 1
a = a + 2
print(a)
Mettre le résultat ici (code et figure).
Erreurs. Rien n'empêche de modifier la valeur du compteur i dans le corps d’une boucle. Cependant il n’agit pas comme un accumulateur.
Observons par exemple le programme suivant, qui est accepté par Python.
for i in range(16):
i=2%i
print (i)
L'exécution de ce programme affiche tous les nombres pairs de 0 jusqu’à 30. On observe que la modification de la variable i par l'affectation i = 2 * i est bien faite à chaque répétition, mais que rien ne subsiste
de cette modification lors des répétitions suivantes.
Pour éviter les confusions, on évite en pratique de modifier la valeur du compteur de boucle.
Mettre le résultat ici (code et figure).
Erreurs. Il ne faut pas utiliser pour une variable de boucle un nom déjà utilisé pour une autre variable encore utile.
Dans cette situation, la variable de boucle et la variable d’origine sont considérées comme la même variable.
i = 3
x = 1
for i in range(5):
print(i)
x = x +1
print(x)
Les valeurs successivement prises par la variable de
boucle viennent remplacer la valeur d’origine, qui est alors irrémédiablement perdue.
"},{"edit":"Mettre le résultat ici (code et figure).
Le compteur de boucle après la boucle
i = 2
x = 1
for i in range(5):
print(i)
x = x +1
print(\"Compteir de boucle\",i)
Le compteur de boucle d'une boucle for a du sens pendant l'exécution de chaque tour de boucle. Cela
dit on peut remarquer dans l'exemple précédent que la variable i existe encore à la fin de l'exécution : elle contient la valeur 4, c'est-à-dire la valeur correspondant au dernier tour de boucle.
Mettre le résultat ici (code et figure).
Jouer avec la numérotation
Jusqu'ici, on à utilisé l'opération range
avec un unique paramètre décrivant le nombre de tours à effectuer. La syntaxe complète de cette opération est en réalité plus riche.
On pourra notamment écrire la ligne
for i in range(début, fin, pas):
avec début, fin et pas trois entiers pour effectuer des tours de boucle tels
que :
- le premier à l'indice début,
- chaque tour à partir du deuxième a un indice déduit de l'indice du tour précédent en ajoutant le pas,
- les tours de boucle s'arrêtent juste avant que l'indice atteigne ou dépasse fin.
Le cas range(n) vu jusqu'ici est donc équivalent à la forme complète range(0, n, 1).
for i in range(5):
print(i)
for i in range(0,5,1):
print(i)
Mais pour avoir des tours de boucle dont les indices vont de 1 à n (5) inclus, il faut avoir range(1,n+1,1)
for i in range(1,5+1,1):
print(i)
De plus, pour avoir, des indices paire, il faut utiliser un pas de 2 :
for i in range(0,5,2):
print(i)
Mettre le résultat ici (code et figure).
Boucles imbriquées.
Le bloc d'instructions répété par une boucle for
peut contenir n'importe quelle instruction, y compris une autre boucle for.
n = 5
m = 4
for i in range(n):
print(\"Début de tour\")
for j in range(m):
print(i, j)
print(\"Fin de tour\")
Mettre le résultat ici (code et figure).
Écrire un programme qui calcule et affiche le résultat de 1 x 2 x ... x 99 x 100.
Mettre le résultat ici (code et figure).
n = 100
s = 1
for i in range(1,n+1):
s = s * i
print(s)
Écrire un programme qui demande un entier n à l’utilisateur, puis calcule et affiche 1 +2 +::.+n, ainsi que l’entier n*(n+1)//2.
Qu’observe-t-on ?
Mettre le résultat ici (code et figure).
n = int(input(\"Un entier ?\"))
s = 0
for i in range(n+1):
s = s + i
print(s)
print(n*(n+1)//2)
Écrire un programme qui demande à l’utilisateur une somme initiale s déposée sur un livret, un taux d'intérêts annuel t exprimé en pourcents et un nombre d’années n, et qui affiche les intérêts perçus chaque année ainsi que le montant total présent sur le livret après n années.
Mettre le résultat ici (code et figure).
#p = float(input(\"intérêts ?\"))
#n = int(input(\"nb années ?\"))
si = 100
p = 5
n = 1
s = si
for i in range(n):
calcul_interets = s * p / 100
s = s + calcul_interets
print(\"intérêts perçus\",s-si)
print(\"montant total\",s)
En utilisant les boucles, écrire un programme qui affiche la table de multiplication de 7.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
for i in range(1,11):
print(i,\"x 7 = \", i * 7)
Écrire un programme qui demande à l'utilisateur un nombre de notes n à prendre en compte, puis à tour de rôle chacune des n notes et son coefficient, et qui enfin affiche la moyenne pondérée.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
Écrire un programme qui demande à l'utilisateur un nombre de chiffres n puis n chiffres, et qui calcule et affiche le nombre formé avec les n chiffres fournis dans l’ordre.
Écrire une variante du même programme
dans lequel les chiffres sont donnés dans l’ordre inverse.
On supposera que les entrées fournies par l'utilisateur sont bien des nombres à un seul chiffre.
Mettre le résultat ici (code et figure).
#On utilise une variable s pour calculer la somme des
#notes pondérées et une variable c pour calculer la somme des coefficients.
n = int (input (\"Combien de notes ? \"))
s = 0
c=0
for i in range(n):
print (\"Entrer la note numéro\", i, end=\"\")
t = int(inputO)
d = int(input(\"Entre le coefficient \"))
s=s+txd
c=c+d
print (\"La moyenne pondérée est\", s / c)
Écrire un programme qui demande à l’utilisateur un nombre entier n et un nombre de chiffres k, et qui affiche successivement les k derniers chiffres de n, en commençant par les unités.
Si n contient moins de k chiffres il suffira d'afficher des zéros à la fin.
Indication : on rappelle que n % 10 renvoie le chiffre des unités de n.
Mettre le résultat ici (code et figure).
#précédents. Cela revient à multiplier par 10 le nombre obtenu jusque-là et à
#ajouter le nouveau chiffre.
n = int(input(\"Entrer un nombre de chiffres : \"))
k=0
for __ in range(n):
c = int(input (\"Entrer le prochain chiffre : \"))
k=10%k+c
print(k)
On considère un hexagone et une étoile à six branches.
Écrire un programme basées sur des boucles qui traçe ces figures avec Turtle.
Mettre le résultat ici (code et figure).
from turtle import *
for __ in range(6):
forward(50)
left(60)
#Etoile, en revenant au centre après chaque rayon tracé.
for __ in range(6):
forward(50)
backward(50)
left(60)
Reprendre l'exercice précédent, en demandant à l’utilisateur un entier n définissant le nombre de côtés du polygone ou le nombre de branches de l'étoile.
Mettre le résultat ici (code et figure).
from turtle import *
n = int (input (\"Nombre de côtés : \"))
for __ in range(n):
forward(50)
left(360/n)
#Etoile, en revenant au centre après chaque rayon tracé.
for __ in range(n):
forward(50)
backward(50)
left(360/n)
Écrire un programme Turtle demandant à l’utilisateur deux entiers n et m et traçant une grille de n x m cases.
Mettre le résultat ici (code et figure).
#On choisit un facteur d’échelle c pour que le dessin
#soit plus joli.
from turtle import *
n = int(input(\"Entrer la hauteur\"))
m = int(input(\"Entrer la largeur\"))
c = 10
for i in range(0, n + 1):
up()
goto(0, c * i)
down()
goto(c * m +1, c * i)
for j in range(0, m + 1):
up()
goto(c * j, 0)
down()
goto(j, c * n + 1)
La suite de Fibonacci est la suite d’entiers (F,) définie par
F0 = 0, F1 = 1
et pour tout entier n à partir de 2 :
Fn = Fn-1 + Fn-2
Écrire un programme qui demande à l’utilisateur un entier n, qu’on supposera supérieur ou égal à 1, et qui affiche la valeur de F,.
Indication : on pourra utiliser deux variables pour mémoriser Fn et Fn-1,
ainsi qu’une variable temporaire.
","title":"Exercice"},{"edit":"Mettre le résultat ici (code et figure).
#n = int(input(\"Entrer la valeur de n : \"))
n=10
#Methode 1
fib_p = 0 # Valeur en n-1
fib_n = 1 # Valeur en n
for __ in range(2, n + 1):
tmp = fib_p
fib_p = fib_n
fib_n = fib_p + tmp
print(fib_n)
#Methode 2
#for __ in range(2, n + 1):
# fib_n = fib_p + fib_n
# fib_p = fib_n - fib_p
# print(fib_n)
#Methode 3
#Variante avec l'instruction d'affectation multiple de Python.
#for __ in range(2, n + 1):
# fib_p, fib_n = fib_n, fib_p + fib_n
# print(fib_n)
Écrire un programme Turtle qui demande un entier n à l’utilisateur et trace une spirale de Fibonacci effectuant n/4 tours. On obtient une spirale de Fibonacci en traçant, pour chaque valeur successive de la suite de
Fibonacci, un quart d’arc de cercle de ce diamètre.
Mettre le résultat ici (code et figure).
from turtle import *
n = int(input(\"Entrer la valeur de n : \"))
fib_p , fib_n = 0, 1
for __ in range(2, n + 1):
circle(fib_n, 90)
fib_p, fib_n = fib_n, fib_p + fib_n