đ Boucles
- while
- Affectation
- for (range)
- Structures combinées
- break / continue / pass
- Boucles imbriquées
- Exercices
La boucle apporte à la programmation une puissance considérable.
Elle permet de répéter des actions, de parcourir des listes, de traiter des données
de maniĂšre efficace.
Elle est un des piliers de la programmation avec les conditions et les fonctions.
En gros, sa structure est la suivante :
Tant que (une certaine condition est vraie) :
# instructions à répéter
# instructions à répéter
# instructions à répéter
Si on exécutait ce pseudo-code, on répéterait l'exécution des lignes 2 à 4 tant que la condition de la ligne 1 est vraie.
DÚs que la condition devient fausse, on sort de la boucle et on continue l'exécution du programme à la ligne 5.
En Python, on utilise le mot-clé while
pour créer une boucle de ce type.
Voici un exemple simple :
compteur = 0
while compteur < 5:
print("Compteur =", compteur)
compteur = compteur + 1 # Incrémente le compteur de 1
print("Fin de la boucle")
Dans cet exemple, la boucle while
continue tant que la variable compteur
est inférieure à 5, c'est-à -dire tant que l'expression compteur < 5
est évaluée à True
.
à chaque itération (tour de la boucle), elle affiche la valeur du compteur (ligne 3) et l'incrémente de 1 (ligne 4).
Quand compteur
atteint 5, la condition (compteur < 5
) devient fausse (False
) et la boucle se termine.
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrĂȘt sur la ligne 1 et avancez une ligne Ă la fois pour suivre l'Ă©volution de la variable compteur
.
Il est crucial de s'assurer que la condition de la boucle deviendra fausse à un moment donné.
Sinon, la boucle continuera indéfiniment, ce qui peut faire planter votre programme.
Dans l'exemple ci-dessus, si on oublie d'incrémenter compteur
, la condition compteur < 5
restera toujours vraie et la boucle ne s'arrĂȘtera jamais.
Pour incrémenter une variable, on peut utiliser l'opérateur d'affectation raccourcie +=
.
Par exemple, au lieu d'écrire compteur = compteur + 1
, on peut écrire compteur += 1
.
Cela fonctionne de la mĂȘme maniĂšre pour les autres opĂ©rations mathĂ©matiques avec les opĂ©rateurs -=
, *=
, /=
, etc.
Voici le mĂȘme exemple avec l'opĂ©rateur +=
:
compteur = 0
while compteur < 5:
print("Compteur =", compteur)
compteur += 1 # Incrémente le compteur de 1
print("Fin de la boucle")
Voici un autre exemple qui utilise une boucle while
pour calculer la somme des nombres de 1 Ă 10 :
somme = 0
nombre = 1
while nombre <= 10:
somme += nombre # Ajoute le nombre courant Ă la somme
nombre += 1 # Passe au nombre suivant
print("La somme des nombres de 1 Ă 10 est :", somme)
Dans cet exemple, la boucle continue tant que nombre
est inférieur ou égal à 10 (nombre <= 10
).
à chaque itération, elle ajoute la valeur de nombre
Ă somme
et incrémente nombre
de 1.
Quand nombre
devient 11, la condition nombre <= 10
devient fausse et la boucle se termine.
Le programme affiche alors la somme totale des nombres de 1 Ă 10.
Exécutez-le en mode débogage pour suivre l'évolution des variables somme
et nombre
à chaque itération!
Nous avons déjà vu l'opérateur d'affectation =
qui permet d'affecter une valeur Ă une variable.
Par exemple :
x = 5
y = 10
Python propose Ă©galement des opĂ©rateurs d'affectation composĂ©s qui permettent de faire des opĂ©rations mathĂ©matiques et de rĂ©affecter le rĂ©sultat Ă la mĂȘme variable en une seule instruction.
Voici les opérateurs d'affectation composés les plus courants :
OpĂ©rateur | Description | Exemple | Ăquivalent Ă |
---|---|---|---|
+= | Addition et affectation | a += b | a = a + b |
-= | Soustraction et affectation | a -= b | a = a - b |
*= | Multiplication et affectation | a *= b | a = a * b |
/= | Division et affectation | a /= b | a = a / b |
%= | Modulo et affectation | a %= b | a = a % b |
//= | Division entiĂšre et affectation | a //= b | a = a // b |
**= | Exponentiation et affectation | a **= b | a = a ** b |
Ces opérateurs sont trÚs utiles pour simplifier le code et rendre les opérations plus concises.
compteur = 0
compteur += 1 # équivalent à compteur = compteur + 1
compteur *= 2 # équivalent à compteur = compteur * 2
print(compteur) # Affiche 2
Lorsqu'on sait à l'avance combien de fois on veut répéter une action, on peut utiliser une boucle for
avec la fonction range()
.
La boucle for
permet une syntaxe plus concise et claire pour ce type précis de situation.
Une boucle for
est un cas particulier de boucle while
et peut ĂȘtre réécrite en boucle while
.
La boucle for
en Python est utilisée pour itérer sur une séquence (comme une liste ou une chaßne de caractÚres) ou sur un objet itérable.
L'une des utilisations les plus courantes de la boucle for
est avec la fonction range()
, qui génÚre une séquence de nombres.
La syntaxe de base est la suivante :
for variable in range(start, stop, step):
# instructions à exécuter
start
: le nombre de départ (inclusif, par défaut 0)stop
: le nombre de fin (exclusif)step
: l'incrément entre chaque nombre (par défaut 1)
Voici quelques exemples d'utilisation de for
avec range()
:
# Exemple 1 : Afficher les nombres de 0 Ă 4
for i in range(5):
print(i)
# Exemple 2 : Afficher les nombres de 1 Ă 5
for i in range(1, 6):
print(i)
# Exemple 3 : Afficher les nombres pairs de 0 Ă 10
for i in range(0, 11, 2):
print(i)
# Exemple 4 : Afficher les nombres de 10 à 1 en ordre décroissant
for i in range(10, 0, -1):
print(i)
Exécutez ces exemples en mode débogage pour bien comprendre le fonctionnement de la boucle for
avec range()
.
Mettez un point d'arrĂȘt sur la ligne 2 de chaque exemple, sur l'instruction for
, et avancez une ligne à la fois pour suivre l'évolution de la variable i
.
Il est possible de combiner les différentes structures de contrÎle pour créer des programmes plus complexes et puissants.
Par exemple, on peut imbriquer des boucles à l'intérieur d'autres boucles, ou utiliser des conditions à l'intérieur de boucles.
Voici un exemple simple qui combine une boucle for
avec une condition if
pour afficher les nombres pairs de 0 Ă 10 :
for i in range(11):
if i % 2 == 0:
print(i)
Dans cet exemple, la boucle for
itĂšre sur les nombres de 0 Ă 10, et la condition if
vérifie si le nombre est pair (c'est-à -dire si le reste de la division par 2 est égal à 0).
Si la condition est vraie, le nombre est affiché.
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrĂȘt sur la ligne 1 et avancez une ligne Ă la fois pour suivre l'Ă©volution de la variable i
et l'évaluation de la condition.
break
, continue
et pass
Parfois, on peut vouloir interrompre une boucle avant qu'elle ne se termine naturellement, ou sauter certaines itérations.
Python fournit trois instructions spéciales pour gérer ces situations : break
, continue
et pass
.
break
Cette instruction permet de sortir immédiatement d'une boucle, qu'elle soit for
ou while
.
Lorsqu'un break
est rencontré, l'exécution du programme continue à la ligne suivant la boucle.
for i in range(10):
if i == 5:
break # Sort de la boucle lorsque i vaut 5
print(i)
print("Fin de la boucle")
Dans cet exemple, la boucle s'arrĂȘte dĂšs que i
atteint 5.
continue
Cette instruction permet de sauter le reste du code dans la boucle pour l'itération en cours et de passer directement à l'itération suivante.
for i in range(10):
if i % 2 == 0:
continue # Saute les nombres pairs
print(i)
Ici, seuls les nombres impairs sont affichés, car les nombres pairs sont ignorés grùce à continue
.
pass
Cette instruction est un "no-op" (no operation), c'est-Ă -dire qu'elle ne fait rien.
Elle est souvent utilisĂ©e comme un espace rĂ©servĂ© dans des blocs de code oĂč une instruction est requise syntaxiquement mais oĂč aucune action n'est nĂ©cessaire.
for i in range(5):
if i < 3:
pass # Ne fait rien pour i < 3
else:
print(i)
Dans cet exemple, rien ne se passe pour les valeurs de i
inférieures à 3, mais pour les autres valeurs, elles sont affichées.
Exécutez ces exemples en mode débogage pour bien comprendre comment chaque instruction affecte le flux d'exécution de la boucle.
Mettez des points d'arrĂȘt aux endroits stratĂ©giques et avancez ligne par ligne pour observer le comportement du programme.
Il est possible de placer une boucle à l'intérieur d'une autre boucle.
On parle alors de boucles imbriquées.
Voici un exemple simple avec deux boucles for
imbriquées pour afficher une table de multiplication :
for i in range(1, 6): # Boucle extérieure pour les lignes
for j in range(1, 6): # Boucle intérieure pour les colonnes
print(i * j, end='\t') # Affiche le produit avec une tabulation
print() # Nouvelle ligne aprĂšs chaque ligne de la table
Dans cet exemple, la boucle extérieure itÚre sur les valeurs de i
de 1 Ă 5, et pour chaque valeur de i
, la boucle intérieure itÚre sur les valeurs de j
de 1 Ă 5.
Le produit i * j
est affiché dans une grille formatée.
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrĂȘt sur la ligne 1 et avancez une ligne Ă la fois pour suivre l'Ă©volution des variables i
et j
.
while
Voici un exemple similaire utilisant des boucles while
imbriquées pour afficher un triangle d'étoiles :
lignes = 5
i = 1
while i <= lignes: # Boucle extérieure pour les lignes
j = 1
while j <= i: # Boucle intérieure pour les étoiles dans chaque ligne
print('*', end=' ') # Afficher une étoile sans générer un saut de ligne
j += 1
print() # Nouvelle ligne aprÚs chaque ligne d'étoiles
i += 1
Dans cet exemple, la boucle extérieure contrÎle le nombre de lignes, tandis que la boucle intérieure contrÎle le nombre d'étoiles affichées dans chaque ligne.
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Mettez un point d'arrĂȘt sur la ligne 2 et avancez une ligne Ă la fois pour suivre l'Ă©volution des variables i
et j
.
Voici une fonction qui prend comme paramĂštres une largeur et une hauteur, et qui affiche un rectangle de #
de ces dimensions :
def afficher_rectangle(largeur, hauteur):
for i in range(hauteur): # Boucle pour chaque ligne
for j in range(largeur): # Boucle pour chaque colonne
print('#', end='') # Affiche un '#' sans saut de ligne
print() # Nouvelle ligne aprĂšs chaque ligne de '#'
afficher_rectangle(5, 3)
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
Il devrait afficher :
#####
#####
#####
Voici maintenant une version qui utilise la concaténation de chaßnes de caractÚres (str) pour construire chaque ligne avant de l'afficher :
def afficher_rectangle(largeur, hauteur):
for i in range(hauteur): # Boucle pour chaque ligne
ligne = '' # Initialise une chaĂźne vide pour la ligne
for j in range(largeur): # Boucle pour chaque colonne
ligne += '#' # ConcatĂšne un '#' Ă la chaĂźne de la ligne
print(ligne) # Affiche la ligne complĂšte
afficher_rectangle(5, 3)
Vous remarquerez que le rĂ©sultat est le mĂȘme, mais la mĂ©thode est diffĂ©rente.
Entre autres, cela évite d'utiliser print()
Ă chaque itĂ©ration de la boucle intĂ©rieure, ce qui peut ĂȘtre plus efficace pour de grandes dimensions.
Exécutez ce code en mode débogage pour bien voir la str
ligne
s'allonger à chaque itération de la boucle intérieure.
âïž Exercices de comprĂ©hensionâ
Produisez la trace du code suivant :
def double(x, y, z):
b = 9
return x * y + z - x
a = 5
b = 6
z = 7
a = double(z, b, a)
Validez ensuite votre réponse en exécutant le programme en mode débogage.
Faites la trace de ce programme :
mystere = 1
while mystere < 16 :
mystere += mystere
print(mystere)
print("FIN DU PROGRAMME")
Validez ensuite votre réponse en exécutant le programme en mode débogage.
Faites la trace de ce programme :
compteur = 1
nombre = 1
while compteur < 3:
nombre = nombre + compteur
if compteur % 2 == 0:
nombre = nombre + 3
compteur += 1
nombre += 100
print(f"compteur = {compteur} nombre = {nombre}")
Validez ensuite votre réponse en exécutant le programme en mode débogage.
Faites la trace d'exécution du code suivant :
for i in range(1, 5):
for j in range(4, 6):
print(str(i) + str(j))
Validez ensuite votre réponse.
Faites la trace d'exécution du code suivant :
for i in range(1, 5):
for j in range(4, 6):
print(str(i + j))
Validez ensuite votre réponse.
En exécutant ce code en mode débogage, déterminez :
- combien de fois la ligne 4 est exécutée,
- les valeurs successives de
resultat
.
def factorielle(n):
resultat = 1
for i in range(1, n + 1):
resultat *= i
return resultat
r = factorielle(9)
print(r)
ExĂ©cutez ce code en mode dĂ©bogage et, en suivant cette recette, utilisez la fonctionnalitĂ© "Evaluate Expression" pour calculer les expressions suivantes lorsque l'exĂ©cution est arrĂȘtĂ©e Ă la ligne 7 (mettez un point d'arrĂȘt!) :
a + b
c * 2
d and False
b + " world"
a = 7
b = "gna"
c = 9.7
d = True
while (a < 999):
a += c * 3
c = c * (a / c)
b = str(c) + b
đš Exercices de crĂ©ationâ
Afficher 5 chiffres aléatoires les uns en dessous des autres.
- Les chiffres doivent ĂȘtre compris dans l'ensemble 1, 2, 3, 4, 5.
- Un mĂȘme chiffre peut ĂȘtre affichĂ© plusieurs fois.
Construisez un nombre composé de 5 chiffres entiers aléatoires, puis affichez-le à la console.
- Chaque chiffre doit ĂȘtre choisi alĂ©atoirement, et appartenir uniquement Ă lâensemble suivant : 5, 6, 7, 8, 9.
- Un mĂȘme chiffre peut ĂȘtre utilisĂ© plusieurs fois.
Par exemple, si vous obtenez les aléatoirement les chiffres : 7 5 9 6 8 vous devez construire le nombre 75968
Ne vous contentez pas de faire un print
des chiffres individuellement.
Vous devez construire un nombre entier au fur et à mesure avec les chiffres obtenus aléatoirement.
Utilisez une variable pour stocker le nombre en cours de construction, sous forme de str
que vous allongez avec de la concatĂ©nation. Lorsque le nombre est fini d'ĂȘtre construit, affichez-le.
Vous pouvez utiliser la fonction str()
pour convertir un chiffre en chaßne de caractÚres, puis les concaténer pour former le nombre final.
Par exemple :
pseudo = "ChatmouraĂŻ"
pseudo += str(42) # Transforme le int 42 en str et le concatĂšne Ă la fin de pseudo
print(pseudo) # Affiche "ChatmouraĂŻ42"
Construisez un nombre composé de 10 chiffres entiers aléatoires, puis affichez-le à la console.
- Les chiffres pairs (0, 2, 4, 6, 8) doivent composer la partie entiĂšre du nombre.
- Les chiffres impairs (1, 3, 5, 7, 9) doivent composer la partie décimale du nombre.
Par exemple, si vous obtenez les aléatoirement les chiffres : 9 5 2 4 7 5 2 1 3 2 vous devez construire le nombre 2422.957513
Vous pouvez construire la partie entiÚre et la partie décimale séparément, puis les combiner pour former le nombre final.
Ăcrivez un programme qui choisit un nombre entier alĂ©atoire entre 0 et 100.
L'utilisateur doit deviner ce nombre.
Tant que la réponse est incorrecte, le programme indique si le nombre à deviner est plus haut ou plus bas.
Lorsqu'il trouve le bon nombre, le programme le félicite.
Exemple de messages :
â "Plus haut!"
â "Plus bas!"
â "Bravo humain, vous avez trouvĂ© le nombre!"
Vous pouvez utiliser la fonction input()
à l'intérieur d'une boucle!
Créez un programme affichant les 100 premiers nombres de la suite de Fibonacci.
Voici les 10 premiers nombres : 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
Dans cette suite, les nombres sont toujours la somme des 2 nombres précédents. Par exemple :
- le nombre 8 s'obtient en additionnant 3 + 5.
- le nombre 13 s'obtient en additionnant 5 + 8.
Les valeurs doivent ĂȘtre affichĂ©es avec print()
au fur et à mesure qu'elles sont calculées.
Contraintes
- Vous n'avez droit qu'Ă 3 variables.
- Vous devez utilisez une boucle.
- Une va servir à contenir le nouveau nombre calculé.
- Une va servir à représenter le nombre précédent.
- Une va servir à représenter le nombre précédent du précédent.
Nous allons transformer un code rĂ©pĂ©titif affichant des lignes dâĂ©toiles sur plusieurs lignes
en une version plus propre et flexible grĂące Ă lâutilisation de boucles.
#Ligne #1
print('*', end='')
print()
#Ligne #2
print('*', end='') # Affiche une étoile et évite le saut de ligne
print('*', end='')
print() # GénÚre une ligne vide
#Ligne #3
print('*', end='')
print('*', end='')
print('*', end='')
print()
#Ligne #4
print('*', end='')
print('*', end='')
print('*', end='')
print('*', end='')
print()
đȘ ĂTAPES Ă SUIVREâ
-
đ COMPRENDRE LE MOTIF
Exécutez le code dans PyCharm et observez le motif affiché.
Chaque ligne contient un nombre croissant dâĂ©toiles, allant de 1 Ă 4. -
đ IDENTIFIER LA RĂPĂTITION
Tentez d'observer la répétition et tentez de voir comment on peut généraliser le tout.
Pour chaque ligne, vous remarquez qu'on fait toujours les mĂȘmes 2 actions :- Afficher un nombre variable d'Ă©toiles selon la ligne
- Puis réaliser un saut de ligne.
-
đ PLANIFIER LA RĂSOLUTION Ă L'AIDE DE BOUCLES
Vous aurez besoin d'une boucle pour répéter ces 2 ensembles d'actions pour chacune des lignes.
Petit problÚme : le nombre d'instructions pour afficher des étoiles est variable selon la ligne... que faire?
Vous allez avoir besoin d'une boucle pour représenter la création des étoiles!
Vous aurez donc une boucle de création de lignes, et à l'intérieur une boucle de création d'étoiles. -
đšđ»âđ» CODER
Vous avez assez philosophié, maintenant codez!
Lorsque vous avez fini, votre code sera générique et flexible!
Vous seriez capable d'afficher 20 lignes au lieu de 4 avec un p'tit changement mineur!
Ă l'aide de boucles, faites un programme permettant d'afficher cette pyramide :
*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
Mettez le code dans une fonction nommée pyramide
qui prend la hauteur en paramĂštre.
Il faut par exemple que ces 3 appels :
pyramide(5)
pyramide(3)
pyramide(7)
produisent exactement cette sortie :
*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
*
* * *
* * * * *
*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
* * * * * * * * * * *
* * * * * * * * * * * * *
Appelez votre fonction pour générer une pyramide haute de 51 lignes.
Puis une, haute de 101 lignes!
đŻ Solutions des exercices
Un solutionnaire possible pour chaque exercice est disponible en format vidĂ©o avec des explications. Vous pouvez vous en servir pour comparer votre solution avec une solution possible jugĂ©e optimale et vous dĂ©bloquer aprĂšs un long moment bloquĂ© sur un exercice (ex. 20 minutes) et aprĂšs avoir utilisĂ© le dĂ©gogueur pour essayer par vous-mĂȘme de trouver le problĂšme.
Il est tout Ă fait normal que certains problĂšmes demandent du temps, de la rĂ©flexion, et parfois mĂȘme un peu de frustration. Câest prĂ©cisĂ©ment dans ces moments dâeffort que lâapprentissage sâancre rĂ©ellement.
Consulter un solutionnaire avant dâavoir tentĂ© lâexercice par soi-mĂȘme, ou le parcourir trop rapidement, revient Ă court-circuiter le processus dâapprentissage. Ce nâest pas simplement contre-productif, câest pĂ©dagogiquement dĂ©sastreux.
En sautant lâĂ©tape de la rĂ©flexion personnelle, on prive son cerveau de lâoccasion de construire des connexions durables. Et Ă force de rĂ©pĂ©ter ce rĂ©flexe, on risque de passer Ă cĂŽtĂ© des compĂ©tences essentielles, ce qui peut mener Ă des Ă©checs plus tard, mĂȘme si tout semble facile sur le moment. Alors oui, prenez le temps. Lâerreur fait partie du jeu. Câest en cherchant, en tĂątonnant, en doutant, quâon devient rĂ©ellement compĂ©tent. Le solutionnaire doit ĂȘtre un outil de validation, pas un raccourci.
đš Solution des exercices de crĂ©ation :
Afficher 5 chiffres aléatoires,
Construire nombre #1,
Construire nombre #2,
Jeu de devinette numérique,
Afficher Fibonacci,
Affichage d'étoiles #1,
Affichage d'étoiles #2