15 minutes de Python
Boucle for : répéter un bloc d’instructions
Boucle for : répéter un bloc d’instructions
Il arrive que l’on ait besoin de répéter plusieurs fois une même instruction : par exemple afficher plusieurs valeurs, additionner une suite de nombres, simuler plusieurs expériences aléatoires, etc. Quand le nombre de répétitions est connu mais important, il n’est évidemment pas réaliste de réécrire la même instruction autant de fois que nécessaire.
La boucle for permet justement de faire exécuter automatiquement plusieurs fois un même bloc
d’instructions.
Générer une liste de valeurs
Pour pouvoir répéter des instructions, Python a besoin d’une suite de valeurs sur lesquelles faire tourner la boucle.
La fonction range permet de générer très facilement ce type de suite.
-
range(n)génère les valeurs0, 1, 2, ..., n-1, -
range(p, n)génère les valeursp, p+1, ..., n-1, -
range(p, n, r)génère les valeursp, p+r, p+2r, ...tant que la valeur reste strictement inférieure àn.
for i in range(5):
print(i)
Ce script affiche exactement :
0, puis 1, puis 2, puis 3, puis 4.
for i in range(2, 7):
print(i)
Ce script affiche :
2, 3, 4, 5, 6.
for i in range(1, 10, 3):
print(i)
Ce script affiche :
1, 4, 7.
Fonctionnement d’une boucle for
for i in range(n):
instruction_1
instruction_2
instruction_3
L’instruction for i in range(n) signifie :
pour chaque valeur prise successivement par i
(0, puis 1, puis 2, …, puis n-1),
Python exécute toutes les instructions qui sont indentées sous la ligne du for.
L’indentation est donc essentielle : ce sont uniquement les lignes décalées vers la droite qui sont répétées. Toute ligne non indentée n’est exécutée qu’une seule fois, après la fin de la boucle.
En pratique, indenter une ligne signifie la faire commencer par un certain nombre d’espaces (toujours le même à l’intérieur d’un même bloc) ou par une tabulation. Cette indentation indique à Python quelles instructions appartiennent à la boucle.
for i in range(5): print(i) # indentée → répétée print("fin") # non indentée → exécutée une seule foisPar exemple, pour calculer la somme \( \displaystyle \sum_{k=0}^n k\), on utilise une variable initialisée à 0, puis on ajoute à chaque tour la valeur de \( k \) pour \( k=0,1,2,\dots,n\).
n = int(input("n = "))
s = 0
for k in range(n+1):
s = s + k
print(s)
Indentation : une ligne dans la boucle ou en dehors
Les lignes indentées sous le for sont exécutées à chaque tour.
Une ligne non indentée est exécutée une seule fois, après la boucle.
# Premier script
n = int(input("n = "))
s = 0
for k in range(n+1):
s = s + k
print(s)
# Deuxième script
n = int(input("n = "))
s = 0
for k in range(n+1):
s = s + k
print(s)
-
Dans le premier script,
print(s)est dans la boucle : le programme affiche la valeur desà chaque tour, donc plusieurs lignes. -
Dans le deuxième script,
print(s)est en dehors de la boucle : le programme n’affiche qu’une seule valeur, la valeur finale des.
Exemple
import numpy.random as rd
compteur = 0
for i in range(10):
lancer = rd.randint(2)
if lancer == 1:
compteur = compteur + 1
print(compteur)
Explication
-
import numpy.random as rd- On importe le module qui permet de générer des valeurs aléatoires.
-
compteur = 0- On initialise un compteur à 0.
- Ce compteur représentera le nombre de piles obtenues.
-
for i in range(10):- La boucle s’exécute 10 fois.
- La variable
iprend successivement les valeurs0, 1, ..., 9.
-
lancer = rd.randint(2)rd.randint(2)renvoie0ou1de manière équiprobable.- On peut interpréter
1comme « pile » et0comme « face ».
-
if lancer == 1:- Si le lancer vaut
1, on a obtenu pile. - Le programme augmente alors le compteur de 1.
- Si le lancer vaut
-
print(compteur)- Après les 10 lancers, le programme affiche exactement le nombre de piles obtenues.
Trois commandes utiles aujourd’hui
Clique sur une carte pour voir l’instruction utile.
a**b
Cette expression permet de calculer une puissance.
a**bsignifie \(a^b\),aest la base,best l’exposant.
Par exemple, 2**5 renvoie \(2^5 = 32\).
rd.random()rd.randint(a, b)
Ces instructions permettent de générer des nombres aléatoires.
rd.random()renvoie un réel choisi au hasard dans \([0,1[\),rd.randint(a, b)renvoie un entier choisi au hasard entreaetb-1.
Par exemple, rd.randint(2) renvoie 0 ou 1 de manière équiprobable.
np.sqrt(x)
Cette instruction permet de calculer la racine carrée d’un réel positif.
np.sqrt(x)renvoie \(\sqrt{x}\),- il faut au préalable importer la bibliothèque avec
import numpy as np.
Par exemple, si x = 9, alors np.sqrt(x) renvoie 3.0.
Un exercice pour vérifier ta maîtrise
Compléter le script pour qu’il demande un entier n et calcule la somme
\(\displaystyle \sum_{k=1}^{n} k^2\).
Le programme devra afficher la valeur finale de cette somme.
n = int(input("n = "))
s = 0
for k in range(1, n+1):
s = s + k**2
print(s)
Explication
-
n = int(input("n = "))- Le programme demande un entier
n. - Cette valeur servira de borne pour la somme.
- Le programme demande un entier
-
s = 0- On initialise un accumulateur destiné à stocker la somme.
-
for k in range( ... ):- Il faut choisir une instruction
rangequi fait prendre àksuccessivement les valeurs1, 2, ..., n. - On utilise donc
range(1, n+1). - La ligne indentée est alors exécutée pour chacune de ces valeurs.
- Il faut choisir une instruction
-
s = s + k**2- À chaque tour de boucle, on ajoute le carré de
kà la somme. - Après la fin de la boucle,
sest égal à \(\sum_{k=1}^{n} k^2\).
- À chaque tour de boucle, on ajoute le carré de
-
print(s)- Le programme affiche exactement la valeur finale de la somme.
Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Analyser un code
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits.
L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles
et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.
Niveau 2 Compléter un code
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette du programme est fourni : il te reste à compléter certaines instructions
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire un code complet
Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Il faut être membre et connecté pour accéder aux exercices et aux corrigés.