đ Boucles et code robuste
- range / for
- for + if
- Imbrication
- break / continue
- input()
- try/except
- DRY
- if compact
- Trace
- Activités
for?Ă la rencontre 4, vous avez Ă©crit ce compteur avec un while. Voici le mĂȘme programme avec un for :
Avec while
compteur = 0 # 1. initialisation
while compteur < 5: # 2. condition
print(compteur)
compteur += 1 # 3. mise Ă jour
Avec for
for compteur in range(5): # 1, 2 et 3 en une seule ligne!
print(compteur)
Les deux affichent 0, 1, 2, 3, 4.
Avec for, les 3 ingrédients de la boucle while sont pris en charge automatiquement : impossible d'oublier la mise à jour et de créer une boucle infinie!
đ La boucle for est donc un cas particulier de while, plus pratique quand on sait d'avance combien de tours on veut faire.
forLa boucle for parcourt une séquence de valeurs une par une, et exécute les instructions du bloc à chaque itération (à chaque tour de boucle) :
for i in range(start, stop, step):
# instructions répétées à chaque itération
à chaque itération, i prend automatiquement la valeur suivante dans la séquence produite par range().
range()range() génÚre une séquence de nombres. Il existe 3 façons de l'appeler selon le nombre de paramÚtres :
range(stop): part de0, avance de1en1, s'arrĂȘte avantstoprange(start, stop): part destart, avance de1en1, s'arrĂȘte avantstoprange(start, stop, step): part destart, avance destepenstep, s'arrĂȘte avantstop
| Appel | Ăquivaut Ă la liste |
|---|---|
| range(5) | [0, 1, 2, 3, 4] |
| range(1, 5) | [1, 2, 3, 4] |
| range(0, 11, 2) | [0, 2, 4, 6, 8, 10] |
| range(5, 0, -1) | [5, 4, 3, 2, 1] |
range(), c'est comme une liste de nombresParcourir un range() revient exactement à parcourir la liste des nombres qu'il produit. Ces deux boucles sont équivalentes :
Avec range()
for i in range(5):
print(i)
Avec une liste écrite à la main
for i in [0, 1, 2, 3, 4]:
print(i)
Les deux affichent 0, 1, 2, 3, 4 : à chaque tour, i prend la valeur suivante de la séquence.
range() nous Ă©vite simplement d'Ă©crire la liste nous-mĂȘmes, ce qui serait impossible pour range(100000)!
đĄ Pour voir les nombres produits par un range(), convertissez-le en liste avec list() :
print(range(5)) # range(0, 5) : pas trĂšs parlant...
print(list(range(5))) # [0, 1, 2, 3, 4]
print(list(range(1, 11, 2))) # [1, 3, 5, 7, 9]
stop n'est jamais incluserange(1, 10) produit les nombres de 1 Ă 9, pas jusqu'Ă 10!
Pour inclure une valeur n, il faut donc s'arrĂȘter avant n + 1 :
n = 10
for i in range(1, n + 1): # i vaut 1, 2, ..., 10
print(i)
C'est l'erreur la plus fréquente avec range() : en cas de doute, exécutez la boucle en mode débogage et vérifiez la derniÚre valeur de i.
đ§ PrĂ©disez avant de lire! Pour chaque exemple, cachez le commentaire de droite et Ă©crivez sur papier la liste des valeurs que prendra i.
Vérifiez ensuite votre réponse avec print(list(range(...))).
# Exemple 1 : un seul paramĂštre â part de 0, s'arrĂȘte avant 5
for i in range(5): # comme for i in [0, 1, 2, 3, 4]
print(i)
# Exemple 2 : part de 1, s'arrĂȘte avant 6
for i in range(1, 6): # comme for i in [1, 2, 3, 4, 5]
print(i)
# Exemple 3 : avance de 2 en 2 â seulement les nombres pairs
for i in range(0, 11, 2): # comme for i in [0, 2, 4, 6, 8, 10]
print(i)
# Exemple 4 : step nĂ©gatif â on descend, et on s'arrĂȘte avant 0
for i in range(5, 0, -1): # comme for i in [5, 4, 3, 2, 1]
print(i)
đ ExĂ©cutez ces exemples en mode dĂ©bogage, un Ă la fois.
Mettez un point d'arrĂȘt sur le for et avancez ligne par ligne pour voir i changer de valeur Ă chaque itĂ©ration.
for, range() et len()Puisque range() produit une sĂ©quence d'index (0, 1, 2âŠ), on peut l'utiliser pour accĂ©der Ă chaque Ă©lĂ©ment d'une liste, un par itĂ©ration.
len(liste) retourne le nombre d'éléments d'une liste. Donc range(len(liste)) génÚre exactement les bons index pour parcourir toute la liste :
temperatures = [21.5, 23.0, 19.8]
nb_mesures = len(temperatures) # nb_mesures vaut 3
for i in range(nb_mesures): # i prendra les valeurs 0, 1, 2
print(temperatures[i]) # accÚde à l'élément à la position i
# On aurait pu écrire directement :
# for i in range(len(temperatures)):
Au 1er tour : i vaut 0 â temperatures[0] â 21.5
Au 2e tour  : i vaut 1 â temperatures[1] â 23.0
Au 3e tour  : i vaut 2 â temperatures[2] â 19.8
đ ExĂ©cutez ce code en mode dĂ©bogage et observez i et temperatures[i] Ă©voluer ensemble Ă chaque itĂ©ration.
i : utiliser _Parfois, on veut simplement répéter une action un certain nombre de fois, sans jamais utiliser la valeur de i à l'intérieur de la boucle.
Par exemple, afficher 5 fois le mĂȘme message :
for i in range(5):
print("Bienvenue!") # i n'est pas utilisé
Dans ce cas, nommer la variable i est trompeur : ça laisse croire qu'on va s'en servir, alors qu'on ne l'utilise pas.
La convention en Python est d'utiliser _ (un tiret bas) pour signaler explicitement que la variable est intentionnellement ignorée :
for _ in range(5):
print("Bienvenue!") # on répÚte 5 fois, la valeur du tour ne nous intéresse pas
Le résultat est identique, mais _ communique clairement l'intention : "je n'ai pas besoin de savoir à quel tour je suis, je veux juste répéter."
đ RĂšgle simple : si on utilise la variable de boucle dans le bloc (temperatures[i], i * 2, etc.), on la nomme i. Si on ne l'utilise jamais, on utilise _.
for ou while? Savoir choisirLa rĂšgle est simple : for quand on connaĂźt le nombre de tours d'avance, while quand on ne le connaĂźt pas.
On utilise un for quand le nombre d'itérations est connu ou calculable avant d'entrer dans la boucle :
- Afficher les 12 mois de l'annĂ©e â on sait qu'il y en a exactement 12.
- Parcourir une liste de 30 Ă©tudiants â
len(liste)nous donne le compte d'avance. - Calculer la table de multiplication de 7 (de 1 Ă 10) â exactement 10 tours.
- RĂ©pĂ©ter une action 5 fois â le nombre est fixĂ© d'avance.
On n'a pas le choix d'utiliser un while quand le nombre d'itérations dépend de quelque chose qui survient pendant l'exécution, donc impossible à connaßtre d'avance :
- Redemander un mot de passe tant qu'il est incorrect â l'utilisateur pourrait le rĂ©ussir au 1er essai... ou au 50e. Impossible Ă prĂ©voir.
- GĂ©nĂ©rer des nombres alĂ©atoires jusqu'Ă tomber sur un 6 â ça pourrait arriver tout de suite ou prendre des dizaines de tours.
- Continuer une partie tant que le joueur n'a pas perdu â on ne sait pas combien de tours durera la partie.
- Lire des donnĂ©es tant qu'il en reste Ă lire â le nombre dĂ©pend du contenu du fichier.
đ Le test mental : « Est-ce que je peux Ă©crire le nombre de tours sur un papier AVANT de lancer la boucle? » Si oui â for. Si non â while.
Les explications de cette section étaient-elles claires ?
for + ifUn if placé dans une boucle for est évalué à chaque tour : selon la valeur courante, son bloc est exécuté ou non.
On peut ainsi traiter chaque valeur différemment.
à la rencontre 4, vous avez combiné while et if pour afficher les nombres pairs de 0 à 10.
Voici le mĂȘme exemple avec une boucle for : plus besoin d'initialiser ni d'incrĂ©menter le compteur vous-mĂȘme!
for i in range(11):
if i % 2 == 0:
print(i)
La boucle for parcourt les nombres de 0 à 10, et le if vérifie si le nombre est pair (reste de la division par 2 égal à 0). Si oui, le nombre est affiché.
ExĂ©cutez ce code en mode dĂ©bogage : mettez un point d'arrĂȘt sur la ligne 1 et avancez une ligne Ă la fois pour suivre i et l'Ă©valuation de la condition.
if est-il toujours nécessaire?Pour les nombres pairs, on aurait pu s'en passer : range(0, 11, 2) les produit directement, sans if!
Le if devient indispensable quand les valeurs voulues ne suivent pas un pas régulier.
Par exemple, afficher les nombres de 1 Ă 30 divisibles par 3 ou par 5 :
for i in range(1, 31):
if i % 3 == 0 or i % 5 == 0:
print(i)
Affiche (un par ligne) : 3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24, 25, 27, 30. Aucun step ne pourrait produire cette suite!
đ RĂšgle simple : les valeurs avancent d'un pas rĂ©gulier â utilisez le step de range(); elles dĂ©pendent d'une condition â utilisez un if.
On parcourt une liste de températures : on affiche un message pour chacune et on compte les fiÚvres.
temperatures = [36.5, 38.2, 37.1, 39.8, 36.9]
nb_fievres = 0 # Compteur initialisé AVANT la boucle
for i in range(len(temperatures)):
if temperatures[i] > 37.5:
print(f"{temperatures[i]} °C : fiÚvre!")
nb_fievres += 1 # Augmenté SEULEMENT si la condition est vraie
else:
print(f"{temperatures[i]} °C : normale")
print(f"Nombre de fiĂšvres : {nb_fievres}") # AffichĂ© APRĂS la boucle
nb_fievres est une variable accumulatrice : un compteur qui n'augmente que lorsque la condition du if est vraie.
Affichage :
36.5 °C : normale
38.2 °C : fiÚvre!
37.1 °C : normale
39.8 °C : fiÚvre!
36.9 °C : normale
Nombre de fiĂšvres : 2
đ ExĂ©cutez ce code en mode dĂ©bogage et observez comment i, temperatures[i] et nb_fievres Ă©voluent Ă chaque tour.
print du total?Un print indenté dans la boucle s'exécute à chaque tour :
nb_fievres = 0
for i in range(len(temperatures)):
if temperatures[i] > 37.5:
nb_fievres += 1
print(f"Nombre de fiĂšvres : {nb_fievres}") # â Dans la boucle : affichĂ© 5 fois (0, 1, 1, 2, 2)
Pour afficher le total une seule fois, le print doit ĂȘtre aprĂšs la boucle, au mĂȘme niveau d'indentation que le for :
nb_fievres = 0
for i in range(len(temperatures)):
if temperatures[i] > 37.5:
nb_fievres += 1
print(f"Nombre de fiĂšvres : {nb_fievres}") # â
AprÚs la boucle : affiché une fois (2)
Les explications de cette section étaient-elles claires ?
Il est possible de placer une boucle à l'intérieur d'une autre boucle : on parle alors de boucles imbriquées.
đĄ L'idĂ©e clĂ© : la boucle intĂ©rieure fait tous ses tours pour CHAQUE tour de la boucle extĂ©rieure.
for i in range(1, 4): # Boucle extérieure : i vaut 1, 2, 3
for j in range(1, 3): # Boucle intérieure : j vaut 1, 2
print(f"i = {i}, j = {j}")
Affichage :
i = 1, j = 1
i = 1, j = 2
i = 2, j = 1
i = 2, j = 2
i = 3, j = 1
i = 3, j = 2
- Pendant que
ivaut 1,jprend toutes ses valeurs (1, puis 2). Ensuite seulement,ipasse à 2⊠etjrecommence à 1. - Au total, la ligne 3 est exécutée 3 à 2 = 6 fois (3 tours extérieurs à 2 tours intérieurs).
ExĂ©cutez ce code en mode dĂ©bogage : mettez un point d'arrĂȘt sur la ligne 1 et avancez une ligne Ă la fois pour voir j recommencer Ă chaque nouvelle valeur de i.
On peut aussi imbriquer des boucles while : chaque boucle a alors besoin de ses propres 3 ingrédients (initialisation, condition, mise à jour).
On veut afficher tous les siÚges d'une salle : 3 rangées (A, B, C) de 4 siÚges chacune.
rangees = ["A", "B", "C"]
for r in range(len(rangees)): # Boucle extérieure : chaque rangée
for siege in range(1, 5): # Boucle intérieure : chaque siÚge de la rangée
print(f"{rangees[r]}{siege}", end=" ")
print() # Nouvelle ligne aprÚs chaque rangée
Affichage :
A1 A2 A3 A4
B1 B2 B3 B4
C1 C2 C3 C4
- La boucle extérieure choisit la rangée; la boucle intérieure parcourt les siÚges de cette rangée.
end=" "remplace le saut de ligne par une espace : les siĂšges d'une mĂȘme rangĂ©e restent sur la mĂȘme ligne (rappel : voir l'onglet Fonctions de la rencontre 2).
â ïž L'indentation du print() vide est essentielle! Il est au niveau de la boucle extĂ©rieure : il s'exĂ©cute une fois aprĂšs chaque rangĂ©e complĂšte.
S'il était indenté dans la boucle intérieure, il s'exécuterait aprÚs chaque siÚge, et chaque siÚge se retrouverait sur sa propre ligne.
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 _ in range(hauteur): # Boucle pour chaque ligne
for _ 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)
Il devrait afficher :
#####
#####
#####
Les valeurs des variables de boucle ne sont jamais utilisées : on les nomme donc _ (voir l'onglet range / for).
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 _ in range(hauteur): # Boucle pour chaque ligne
ligne = '' # Initialise une chaĂźne vide pour la ligne
for _ 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)
Le rĂ©sultat est le mĂȘme, mais la mĂ©thode est diffĂ©rente : on Ă©vite d'appeler print() Ă chaque itĂ©ration de la boucle intĂ©rieure.
Exécutez ce code en mode débogage pour voir la chaßne ligne s'allonger à chaque itération de la boucle intérieure.
Les explications de cette section étaient-elles claires ?
break et continueParfois, on veut interrompre une boucle avant qu'elle se termine naturellement, ou sauter certaines itérations.
Python fournit deux instructions spéciales pour ces situations : break et continue.
break : sortir de la bouclebreak fait sortir immédiatement de la boucle (for ou while). L'exécution continue à la premiÚre ligne aprÚs la boucle.
Il est trÚs utile pour une recherche : dÚs qu'on a trouvé ce qu'on cherche, inutile de continuer à parcourir la liste!
temperatures = [36.5, 37.1, 38.2, 36.9, 39.8]
for i in range(len(temperatures)):
print(f"Vérification de {temperatures[i]} °C")
if temperatures[i] > 37.5:
print(f"PremiÚre fiÚvre trouvée à la position {i}!")
break # On a trouvĂ© : on arrĂȘte de chercher
print("Fin de la recherche")
Affichage :
Vérification de 36.5 °C
Vérification de 37.1 °C
Vérification de 38.2 °C
PremiÚre fiÚvre trouvée à la position 2!
Fin de la recherche
đ Les tempĂ©ratures 36.9 et 39.8 ne sont jamais vĂ©rifiĂ©es : le break a terminĂ© la boucle Ă la position 2.
continue : passer au tour suivantcontinue saute tout le reste du tour en cours et passe directement à l'itération suivante.
Il est utile pour ignorer des valeurs invalides. Ici, un capteur enregistre -999 lorsqu'une mesure a échoué :
mesures = [21.5, -999, 23.0, 19.8, -999]
somme = 0
nb_valides = 0
for i in range(len(mesures)):
if mesures[i] == -999:
continue # Mesure invalide : on passe directement Ă la suivante
print(f"Mesure valide : {mesures[i]}")
somme += mesures[i]
nb_valides += 1
print(f"Moyenne : {somme / nb_valides:.1f}")
Affichage :
Mesure valide : 21.5
Mesure valide : 23.0
Mesure valide : 19.8
Moyenne : 21.4
đ Pour chaque -999, les lignes 7 Ă 9 sont toutes sautĂ©es : la mesure n'est ni affichĂ©e, ni additionnĂ©e, ni comptĂ©e.
break et continue n'agissent que sur la boucle la plus proche (celle dans laquelle ils se trouvent directement) :
for i in range(1, 4):
for j in range(1, 4):
if j == 2:
break # Sort SEULEMENT de la boucle sur j
print(f"i = {i}, j = {j}")
Affichage :
i = 1, j = 1
i = 2, j = 1
i = 3, j = 1
đ Le break arrĂȘte la boucle intĂ©rieure, mais la boucle extĂ©rieure continue : i passe quand mĂȘme Ă 2, puis Ă 3.
break et continue sont pratiques, mais ils rendent le chemin d'exécution plus difficile à suivre.
Si une condition claire dans le while ou un simple if suffit, c'est souvent plus lisible. RĂ©servez-les aux cas oĂč ils simplifient vraiment le code : une recherche Ă arrĂȘter dĂšs qu'on a trouvĂ©, des valeurs Ă ignorer, etc.
ExĂ©cutez les exemples de cet onglet en mode dĂ©bogage : avancez ligne par ligne et observez exactement oĂč l'exĂ©cution saute aprĂšs un break ou un continue.
Les explications de cette section étaient-elles claires ?
input()La fonction input() permet de demander Ă l'utilisateur de saisir une valeur au clavier.
Elle peut ĂȘtre utilisĂ©e avec ou sans paramĂštre :
- sans paramĂštre, elle attend simplement une saisie;
- avec un paramĂštre, elle affiche d'abord un message pour guider l'utilisateur.
Essayez ce code dans un script Python :
# Sans paramĂštre
saisie_utilisateur = input() # Attend une saisie de l'utilisateur
print(saisie_utilisateur)
# Avec un paramĂštre
prenom = input("Veuillez saisir votre prénom : ")
print(prenom)
đĄ Terminez toujours le message par une espace ("... prĂ©nom : ") : sinon, ce que l'utilisateur tape se colle directement au texte.
input() met le programme sur pause!Lorsque input(...) est exécutée, le programme attend que l'utilisateur écrive quelque chose et appuie sur la touche Entrée.
C'est donc normal que l'instruction suivante ne soit pas exécutée tant que vous n'avez rien saisi!
Dans PyCharm :
- cliquez dans la console (fenĂȘtre Run) avant de taper votre rĂ©ponse, puis appuyez sur EntrĂ©e;
- en mode dĂ©bogage, la rĂ©ponse se tape dans la console de la fenĂȘtre Debug. Le programme semble « figĂ© » tant que vous n'avez pas rĂ©pondu : il ne plante pas, il vous attend!
input() retourne toujours du texteLa fonction input(...) retourne TOUJOURS une chaĂźne de caractĂšres (str), mĂȘme si l'utilisateur saisit un nombre.
Pour utiliser la valeur dans un calcul, il faut la convertir avec int() ou float() :
# Demander un nombre entier (int)
age = int(input("Entrez votre Ăąge : "))
print(f"Dans 10 ans, vous aurez {age + 10} ans.")
# Demander un nombre décimal (float)
taille = float(input("Entrez votre taille en mĂštres : "))
print(f"Votre taille en centimĂštres est {taille * 100} cm.")
int() convertit la chaßne en nombre entier et float() en nombre décimal.
Sans int() ou float(), Python traite la saisie comme du texte :
age = input("Entrez votre Ăąge : ") # L'utilisateur tape 17
print(age + 10) # â TypeError: can only concatenate str (not "int") to str
a = input("Premier nombre : ") # L'utilisateur tape 5
b = input("DeuxiĂšme nombre : ") # L'utilisateur tape 3
print(a + b) # 53 (les deux textes sont collés, ce n'est pas une addition!)
print(a * 3) # 555 (le texte est répété 3 fois!)
đ Si vous obtenez un TypeError avec str, ou un rĂ©sultat « collĂ© » comme 53, vĂ©rifiez d'abord que vous avez bien converti la saisie.
En français, on écrit souvent 1,75. Mais Python utilise le point comme séparateur décimal :
float("1.75") # â
1.75
float("1,75") # â ValueError: could not convert string to float: '1,75'
Quand votre programme demande un nombre décimal, tapez-le avec un point (1.75).
input() dans une boucleOn peut placer un input() dans une boucle while pour redemander tant que la réponse ne convient pas :
reponse = ""
while reponse != "oui":
reponse = input("Avez-vous terminé? (oui/non) : ")
print("Bravo!")
reponseest initialisée à une chaßne vide avant la boucle, pour que la condition soit vraie au premier tour.- Tant que l'utilisateur ne tape pas exactement
oui, la question est reposée.
Les explications de cette section étaient-elles claires ?
raise met une barriÚre dans une fonctionà la rencontre 4, vous avez protégé la fonction vitesse_moyenne avec raise :
def vitesse_moyenne(distance, temps):
if distance < 0:
raise ValueError("La distance ne peut pas ĂȘtre nĂ©gative.")
if temps == 0:
raise ZeroDivisionError("Le temps ne peut pas ĂȘtre nul.")
if temps < 0:
raise ValueError("Le temps ne peut pas ĂȘtre nĂ©gatif.")
return distance / temps
Le problĂšme : dĂšs qu'une erreur est levĂ©e, tout le programme s'arrĂȘte.
Avec try/except, c'est maintenant l'appelant qui peut décider quoi faire en cas d'erreur.
try/except â mettre un filet de sĂ©curitĂ© Ă l'appeltry/except permet de rattraper une erreur qui se produit, plutĂŽt que de laisser le programme planter.
Exécutez ce code sans try/except, observez l'erreur, puis ajoutez le filet et relancez :
# Sans filet : le programme plante
print(vitesse_moyenne(100, 20)) # â
5.0
print(vitesse_moyenne(-50, 10)) # â Le programme s'arrĂȘte ici avec une erreur
print(vitesse_moyenne(100, 0)) # Jamais atteint
# Avec filet : le programme gĂšre l'erreur proprement
try:
print(vitesse_moyenne(100, 20)) # â
Exécuté normalement
print(vitesse_moyenne(-50, 10)) # â LĂšve ValueError â on saute au except
print(vitesse_moyenne(100, 0)) # âïž Jamais atteint (on est dĂ©jĂ dans le except)
except ValueError as e:
print(f"Une erreur est survenue : {e}")
print("Suite du programme") # â
Le programme continue!
Affichage :
5.0
Une erreur est survenue : La distance ne peut pas ĂȘtre nĂ©gative.
Suite du programme
- DĂšs qu'une erreur survient dans le
try, le reste dutryest sauté et Python exécute le blocexcept. - AprÚs le
except, le programme continue normalement : il ne plante plus! - La variable
econtient le message d'erreur passĂ© Ăraise. On peut l'afficher, l'enregistrer dans un fichier, ou rĂ©agir diffĂ©remment selon l'erreur.
except pour plusieurs types d'erreursvitesse_moyenne peut lever deux types d'exceptions : ValueError (distance ou temps négatif) et ZeroDivisionError (temps nul).
On peut écrire un bloc except pour chaque type, et réagir différemment :
try:
print(vitesse_moyenne(100, 0))
except ValueError as e:
print(f"Valeur invalide : {e}")
except ZeroDivisionError as e:
print(f"Division impossible : {e}")
Affichage :
Division impossible : Le temps ne peut pas ĂȘtre nul.
Python vérifie les blocs except dans l'ordre et exécute seulement le premier qui correspond au type de l'erreur.
input() : l'utilisateur ne tape pas un nombre đUne saisie utilisateur est imprĂ©visible. Si l'utilisateur tape « abc », int() lĂšve une ValueError et le programme plante.
Avec une boucle while et un try/except, on peut redemander jusqu'à obtenir une réponse valide :
valide = False
while not valide:
try:
age = int(input("Quel Ăąge as-tu? "))
valide = True # Atteint seulement si la conversion a réussi
except ValueError:
print("Ce n'est pas un nombre entier, réessayez!")
print(f"Dans 10 ans, tu auras {age + 10} ans.")
Si int() lÚve une erreur, Python saute directement au except : la ligne valide = True n'est pas exécutée et la boucle recommence.
DĂšs qu'une saisie est valide, valide devient True et la boucle se termine.
raise et try/except| MĂ©canisme | RĂŽle | OĂč l'Ă©crire |
|---|---|---|
| raise | Signaler un problĂšme (mettre une barriĂšre) | Dans la fonction, lĂ oĂč les paramĂštres sont vĂ©rifiĂ©s |
| try/except | Attraper un problĂšme (mettre un filet) | Ă l'appel de la fonction, pour gĂ©rer proprement les erreurs et Ă©viter l'arrĂȘt du programme |
đ On utilise raise pour protĂ©ger la fonction, et try/except pour que l'appelant dĂ©cide quoi faire en cas d'erreur.
Ce n'est pas seulement votre code qui peut lever des exceptions â les fonctions de la bibliothĂšque standard de Python le font aussi.
Comprendre quelles erreurs elles peuvent produire vous aide Ă les anticiper et mĂȘme les intercepter (avec un bloc try/except) pour Ă©viter l'arrĂȘt pur et simple du programme.
math â erreurs de domaine mathĂ©matique
import math
math.sqrt(25) # â
5.0
math.sqrt(-1) # â ValueError: math domain error (racine d'un nombre nĂ©gatif)
math.log(100) # â
4.605...
math.log(0) # â ValueError: math domain error (log(0) est indĂ©fini)
math.log(-5) # â ValueError: math domain error (log d'un nĂ©gatif)
math.factorial(5) # â
120
math.factorial(-1)# â ValueError: factorial() not defined for negative values
math.factorial(2.5)# â TypeError: 'float' object cannot be interpreted as an integer
đ Le module math lĂšve une ValueError dĂšs qu'on sort du domaine mathĂ©matique valide (valeur impossible Ă calculer).
int() et float() â erreurs de conversion
int("42") # â
42
int("3.14") # â ValueError: invalid literal for int() with base 10: '3.14'
int("abc") # â ValueError: invalid literal for int() with base 10: 'abc'
float("3.14") # â
3.14
float("abc") # â ValueError: could not convert string to float: 'abc'
đ int() et float() lĂšvent une ValueError si la chaĂźne de caractĂšres ne reprĂ©sente pas un nombre valide.
C'est une erreur trÚs fréquente quand on lit une saisie utilisateur ou des données provenant d'un fichier.
Intercepter ces erreurs avec try/except
Voici un exemple concret qui combine math et la conversion :
import math
def calculer_racine(valeur_texte):
try:
nombre = float(valeur_texte) # Peut lever ValueError si non numérique
resultat = math.sqrt(nombre) # Peut lever ValueError si nombre < 0
return resultat
except ValueError as e:
print(f"Erreur : {e}")
return None
#Toutes les instructions ci-dessous sont exécutées!
print(calculer_racine("25")) # â
5.0
print(calculer_racine("-4")) # â
La fonction gĂšre l'erreur pour Ă©viter l'arrĂȘt du programme et elle retourne None
print(calculer_racine("abc")) # â
La fonction gĂšre l'erreur pour Ă©viter l'arrĂȘt du programme et elle retourne None
a = 1 + 2 # Cette instruction est finalement exécutée!
đ Un seul bloc try/except attrape Ă la fois les erreurs de conversion et les erreurs de domaine, car les deux lĂšvent une ValueError.
L'appel de la fonction calculer_racine() ne causera jamais l'arrĂȘt du programme car les erreurs sont bien attrapĂ©es.
La fonction retourne donc :
- une valeur valide si tout s'est bien passé;
- la valeur
Nonesi une erreur a été attrapée.
Bonne pratique : lire la documentation avant d'utiliser une fonction
Les exemples ci-dessus ne sont pas une liste exhaustive â chaque fonction de Python peut avoir son propre comportement en cas d'erreur.
Avant d'utiliser une fonction inconnue, consultez sa documentation pour savoir quelles exceptions elle peut lever et dans quelles circonstances.
Par exemple, la page de documentation de math.sqrt indique explicitement qu'une ValueError est levĂ©e si l'argument est nĂ©gatif. C'est cette information qui vous permet d'Ă©crire un try/except adaptĂ© â ni trop large (attraper des erreurs imprĂ©vues), ni trop Ă©troit (manquer un cas rĂ©el).
exceptPython permet d'écrire except seul, sans type d'erreur : il attrape alors toutes les erreurs⊠y compris vos propres bogues!
try:
age = int(imput("Quel Ăąge as-tu? ")) # Faute de frappe : imput au lieu de input
except:
print("Ce n'est pas un nombre entier!")
Ce programme affiche toujours « Ce n'est pas un nombre entier! », mĂȘme avant que l'utilisateur ait tapĂ© quoi que ce soit.
La vraie erreur (NameError: name 'imput' is not defined) est cachée : impossible de comprendre ce qui ne va pas!
Avec except ValueError:, seules les erreurs de conversion sont attrapées. La NameError s'affiche normalement, avec un message qui pointe directement vers la faute de frappe.
try/except- đ€ Quand vous intĂ©grez une nouvelle fonction, demandez-vous : « Qu'est-ce qui pourrait mal se passer ici, et est-ce que mon code le gĂšre? »
- đŻ PrĂ©cisez toujours le type d'erreur attendu aprĂšs
except(ex. :except ValueError), jamais unexceptseul. - đ Consultez la documentation d'une fonction inconnue pour savoir quelles exceptions elle peut lever.
Les explications de cette section étaient-elles claires ?
En programmation, on suit le principe DRY (Don't Repeat Yourself, « ne vous répétez pas »).
Du code rĂ©pĂ©tĂ© est plus long Ă lire, et surtout plus difficile Ă modifier : une correction doit ĂȘtre faite Ă chaque endroit oĂč le code a Ă©tĂ© copiĂ©, et il est facile d'en oublier un.
Vous connaissez maintenant trois outils pour éviter la répétition :
| Situation | Outil |
|---|---|
| On rĂ©pĂšte le mĂȘme calcul ou traitement Ă plusieurs endroits du programme | Une fonction (voir l'onglet DRY de la rencontre 3) |
La mĂȘme instruction se retrouve dans tous les blocs d'un if/elif/else | Sortir l'instruction du bloc conditionnel (section 1 ci-dessous) |
| On copie-colle un bloc en changeant seulement quelques valeurs | Une boucle (section 2 ci-dessous) |
1ïžâŁ Dans les structures conditionnellesâ
Si une instruction se retrouve à la fois dans le if et dans le else, elle s'exécutera dans tous les cas de toute façon.
Elle devrait donc ĂȘtre placĂ©e en dehors du bloc conditionnel : soit avant, soit aprĂšs, selon sa position dans les blocs.
Repérez l'instruction répétée inutilement dans les deux blocs :
# Version redondante
temperature = 37.8
if temperature > 37.5:
print("Initialisation du protocole de mesure...") # â RĂ©pĂ©tĂ© au dĂ©but des 2 blocs!
print("â ïž FiĂšvre dĂ©tectĂ©e : consulter un mĂ©decin.")
else:
print("Initialisation du protocole de mesure...") # â RĂ©pĂ©tĂ© au dĂ©but des 2 blocs!
print("â
Température normale.")
Peu importe la valeur de temperature, l'initialisation du protocole est toujours affichée.
La répéter dans les deux blocs est inutile et rend le code plus difficile à maintenir.
# Version sans redondance
temperature = 37.8
print("Initialisation du protocole de mesure...") # â
Exécuté dans tous les cas avant les 2 blocs
if temperature > 37.5:
print("â ïž FiĂšvre dĂ©tectĂ©e : consulter un mĂ©decin.")
else:
print("â
Température normale.")
Le code est plus court, plus lisible, et plus facile Ă modifier : si le message d'initialisation change, on n'a qu'un seul endroit Ă modifier.
MĂȘme problĂšme, mais cette fois l'instruction rĂ©pĂ©tĂ©e se trouve Ă la fin de chaque bloc :
# Version redondante
masse_g = 5.2
volume_mL = 10.0
if masse_g > 0 and volume_mL > 0:
densite = masse_g / volume_mL
print(f"Densité calculée : {densite} g/mL")
print("--- Fin de l'analyse ---") # â RĂ©pĂ©tĂ© Ă la fin des 2 blocs!
else:
print("â ïž ParamĂštres invalides, calcul impossible.")
print("--- Fin de l'analyse ---") # â RĂ©pĂ©tĂ© Ă la fin des 2 blocs!
# Version sans redondance
masse_g = 5.2
volume_mL = 10.0
if masse_g > 0 and volume_mL > 0:
densite = masse_g / volume_mL
print(f"Densité calculée : {densite} g/mL")
else:
print("â ïž ParamĂštres invalides, calcul impossible.")
print("--- Fin de l'analyse ---") # â
Exécuté dans tous les cas aprÚs les 2 blocs
| Position de la redondance | Solution |
|---|---|
| Au début de chaque bloc | Placer l'instruction avant le bloc if |
| Ă la fin de chaque bloc | Placer l'instruction aprĂšs le bloc if/else |
| Au début et à la fin | Placer une instruction avant et une aprÚs |
đ La rĂšgle est simple : si une instruction s'exĂ©cute dans tous les cas, elle ne devrait jamais se retrouver Ă l'intĂ©rieur d'un if ou d'un else.
â ïž On ne peut sortir une instruction que si elle se trouve dans chacun des blocs : le if, chaque elif et le else.
S'il manque dans un seul bloc, elle ne s'exécute pas dans tous les cas : elle doit donc rester à l'intérieur.
Parfois, deux instructions se ressemblent mais ne sont pas identiques : elles ne peuvent donc pas ĂȘtre sorties du bloc.
# â
Ce n'est PAS de la redondance, car les messages sont différents!
ph = 4.2
if ph < 7:
print(f"Le pH de {ph} indique une solution acide.")
else:
print(f"Le pH de {ph} indique une solution basique ou neutre.")
Ici, les deux print contiennent du texte différent. Ils doivent rester dans leurs blocs respectifs.
2ïžâŁ Avec des bouclesâ
Si vous copiez-collez un bloc d'instructions en changeant seulement quelques valeurs, c'est le signe qu'il faut utiliser une boucle.
Voici un programme qui affiche les informations de trois étudiants. Le bloc d'instructions est répété trois fois, seules les valeurs changent :
print("Ătudiant #1")
print("Nom : Félix")
print("Note : 72")
print()
print("Ătudiant #2")
print("Nom : Dayron")
print("Note : 91")
print()
print("Ătudiant #3")
print("Nom : Léa")
print("Note : 58")
print()
Ce code fonctionne, mais il est difficile à maintenir : ajouter un 4e étudiant oblige à copier-coller un nouveau bloc. Et si le format d'affichage change, il faut modifier trois endroits!
En observant les trois blocs, on remarque que seules trois choses varient d'un bloc Ă l'autre :
- Le numéro de l'étudiant (
#1,#2,#3) - Le nom (
Félix,Dayron,Léa) - La note (
72,91,58)
Le numéro correspond simplement à la position dans la liste (index 0, 1, 2), donc on peut le calculer automatiquement avec i + 1.
On regroupe les noms et les notes dans des listes parallĂšles :
noms = ["Félix", "Dayron", "Léa"]
notes = [72, 91, 58]
Maintenant qu'on a les données dans des listes, une seule boucle suffit pour traiter tous les étudiants :
noms = ["Félix", "Dayron", "Léa"]
notes = [72, 91, 58]
nb_elements = len(noms)
for i in range(nb_elements):
print(f"Ătudiant #{i + 1}")
print(f"Nom : {noms[i]}")
print(f"Note : {notes[i]}")
print()
Le résultat affiché est identique à la version redondante, mais le code est bien plus court et plus facile à maintenir.
Pour ajouter un 4e étudiant, on n'ajoute qu'un élément dans chaque liste et la boucle s'adapte automatiquement grùce à len() :
noms = ["Félix", "Dayron", "Léa", "Tristan"]
notes = [72, 91, 58, 83]
nb_elements = len(noms)
for i in range(nb_elements):
print(f"Ătudiant #{i + 1}")
print(f"Nom : {noms[i]}")
print(f"Note : {notes[i]}")
print()
đ Le corps de la boucle n'a pas changĂ© d'une seule ligne. C'est la puissance de combiner les listes et les boucles!
- Repérer le bloc d'instructions qui se répÚte.
- Identifier ce qui change d'une rĂ©pĂ©tition Ă l'autre (les valeurs, le numĂ©ro, le nombre d'Ă©lĂ©mentsâŠ).
- Mettre ces valeurs dans une liste, ou les calculer Ă partir de
i(commei + 1pour le numĂ©ro). - Ăcrire la boucle, avec le bloc commun Ă l'intĂ©rieur.
Vérifiez ensuite que le résultat affiché est identique à celui de la version répétitive.
Les explications de cette section étaient-elles claires ?
Pour une condition simple qui sert à choisir entre deux valeurs, on peut utiliser une forme compacte (appelée aussi expression conditionnelle ou ternaire) :
valeur_si_vrai if condition else valeur_si_faux
â ïž L'ordre est inhabituel : la condition est au milieu! On lit : « valeur_si_vrai si condition, sinon valeur_si_faux ».
Forme standard
age = 20
if age >= 18:
statut = "majeur"
else:
statut = "mineur"
print(statut) # majeur
Forme compacte
age = 20
statut = "majeur" if age >= 18 else "mineur"
print(statut) # majeur
Les deux versions font exactement la mĂȘme chose.
Remarquez que la forme standard répÚte l'affectation statut = ... dans les deux blocs : la forme compacte l'écrit une seule fois (voir l'onglet DRY).
La forme compacte produit une valeur : on peut donc la placer directement dans un print :
age = 20
print("Vous ĂȘtes majeur." if age >= 18 else "Vous ĂȘtes mineur.") # â
Recommandé
Vous rencontrerez aussi cette écriture, avec un print de chaque cÎté :
print("Vous ĂȘtes majeur.") if age >= 18 else print("Vous ĂȘtes mineur.") # Fonctionne, mais dĂ©conseillĂ©
Elle fonctionne, mais elle est déconseillée : la forme compacte sert à choisir une valeur, pas à choisir quelle instruction exécuter.
Il faut tout de mĂȘme savoir la lire (vous la verrez dans une trace).
else est obligatoireContrairement au if standard, la forme compacte doit avoir un else : il faut toujours une valeur, que la condition soit vraie ou fausse.
statut = "majeur" if age >= 18 # â SyntaxError: expected 'else' after 'if' expression
La forme compacte est utile pour des conditions simples et des valeurs courtes.
Pour des conditions plus complexes ou des blocs de plusieurs instructions, utilisez la forme standard avec indentation : elle est plus lisible.
Le mot-clé elif n'existe pas dans la forme compacte. Pour tester plusieurs conditions, on enchaßne des else ... if ... :
score = 85
resultat = "Excellent" if score >= 90 else "Bien" if score >= 75 else "Passable" if score >= 50 else "Ăchec"
print(resultat) # Affiche "Bien"
C'est possible, mais rapidement difficile à lire. DÚs qu'on a besoin de plus de deux possibilités, préférez la forme standard if/elif/else.
La forme compacte sera nécessaire à la rencontre 9, dans les compréhensions de liste.
Les explications de cette section étaient-elles claires ?
đ”ïžââïž Trace d'exĂ©cution avec des structures rĂ©pĂ©titivesâ
Voici un exemple de trace d'exécution contenant des structures répétitives.
Pour la méthode complÚte, consultez la recette Produire une trace et imprimez la feuille de trace.
- Certaines lignes s'exécutent plusieurs fois, c'est le principe de la boucle!
- On indique les lignes qui testent une condition (
whileetfor).
Traceâ
On aura la trace suivante :
| portée globale | |||
|---|---|---|---|
| #ligne | contexte | i | affichage |
| 1 | globale | 0 | |
| 2 | globale | 0 | |
| 3 | globale | 0 | i vaut 0 |
| 4 | globale | 1 | |
| 2 | globale | 1 | |
| 3 | globale | 1 | i vaut 1 |
| 4 | globale | 2 | |
| 2 | globale | 2 | |
| 5 | globale | 2 | fin |
Traceâ
On aura la trace suivante :
| portée globale | |||
|---|---|---|---|
| #ligne | contexte | j | affichage |
| 1 | globale | 0 | |
| 2 | globale | 0 | j vaut 0 |
| 1 | globale | 1 | |
| 2 | globale | 1 | j vaut 1 |
| 1 | globale | 1 | |
| 3 | globale | 1 | fin |
Dans les deux traces ci-dessus, la ligne du while (ligne 2) ou du for (ligne 1) apparaĂźt une fois de plus Ă la fin, sans affichage.
C'est le moment oĂč Python constate qu'il n'y a plus de tour Ă faire et sort de la boucle :
- avec un
while, la condition est évaluée une derniÚre fois et donneFalse(i < 2est faux quandivaut 2); - avec un
for, il ne reste plus de valeur dans lerange(): la variable de boucle garde sa derniĂšre valeur (jreste Ă 1).
đ C'est la ligne qu'on oublie le plus souvent dans une trace : n'oubliez pas de l'inscrire avant de passer Ă la ligne qui suit la boucle!
Les numéros de la colonne #ligne sont exactement ceux qui défilent dans le débogueur, y compris cette derniÚre vérification de la boucle.
AprÚs avoir fait votre trace sur papier, exécutez le code pas à pas (Step Over) et comparez ligne par ligne.
Pour favoriser une progression efficace, ce cours adopte une approche de classe inversée. Ce modÚle déplace l'acquisition théorique hors de la classe pour transformer les heures de rencontre en véritables séances d'application pratique.
-
Ă la maison (Exploration et Appropriation) : Vous ĂȘtes le maĂźtre de votre rythme. Ces activitĂ©s vous permettent de dĂ©couvrir les nouveaux concepts et tester les exemples au moment oĂč vous ĂȘtes le plus concentrĂ©. Si une notion vous semble obscure, n'hĂ©sitez pas Ă poser des questions Ă votre prof au fur et Ă mesure.
-
En classe (Application et Consolidation) : Le temps en prĂ©sentiel est une ressource prĂ©cieuse. Nous l'utilisons pour nous attaquer aux dĂ©fis plus complexes et aux exercices de programmation qui demandent une mobilisation active de vos connaissances. Câest le moment idĂ©al pour obtenir une rĂ©troaction immĂ©diate, collaborer avec vos pairs et bĂ©nĂ©ficier de l'accompagnement de votre enseignant au moment oĂč vous en avez le plus besoin.
Avec les boucles imbriquées, vous pouvez maintenant réaliser la méthode chiffre par chiffre du TP1.
Vous pouvez aussi remplacer la boucle while de vos tests de performance par une boucle for avec range().
- đ ActivitĂ©s Ă faire Ă la maison
- đ« ActivitĂ©s Ă faire en classe
đ§ Auto-validation des connaissancesâ
Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R05. Ne faites ce questionnaire que lorsque vous vous sentez en trÚs bonne maßtrise de la matiÚre. En classe, dÚs votre arrivée, vous aurez un questionnaire trÚs similaire, évalué sommativement, à compléter sans accÚs à aucune documentation.
Ne pas remplir le formulaire diminue fortement vos chances de rĂ©ussir lâĂ©valuation sommative en dĂ©but de rencontre.
Assurez-vous de bien comprendre toutes les notions derriĂšre chaque question.
âïž Exercices de comprĂ©hensionâ
đš Pour rĂ©aliser cet exercice, imprimez le tableau de trace d'exĂ©cution.
En situation d'examen, vous devrez compléter une trace d'exécution sur papier sans utiliser d'ordinateur.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.\
En suivant la recette de trace avec fonctions, complétez le tableau de trace d'exécution ligne par ligne.
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 trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Appel de fonction, paramÚtres et ordre des arguments, return, portée des variables (variable locale b), trace d'exécution, débogueur
while, if, breakđš Pour rĂ©aliser cet exercice, imprimez le tableau de trace d'exĂ©cution.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant les recettes de trace avec boucle et avec condition, complétez le tableau de trace d'exécution ligne par ligne.
compteur = 1
nombre = 1
while compteur < 3:
nombre = nombre + compteur
if compteur % 2 == 0:
break
compteur += 1
print(f"compteur = {compteur} nombre = {nombre}")
Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Boucle while, condition d'arrĂȘt, structure conditionnelle (if), break, opĂ©rateur modulo (%), opĂ©rateur +=, variables accumulatrices, f-string, trace d'exĂ©cution, dĂ©bogueur
range imbriquĂ©, if, continueđš Pour rĂ©aliser cet exercice, imprimez le tableau de trace d'exĂ©cution.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant les recettes de trace avec boucle et avec condition, complétez le tableau de trace d'exécution ligne par ligne.
for i in range(1, 3):
if i == 2:
continue
for j in range(4, 6):
print(i + j)
Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Boucles for imbriquées, range(), structure conditionnelle (if), continue, ordre d'exécution, trace d'exécution, débogueur
if/else + forme compacteđš Pour rĂ©aliser cet exercice, imprimez le tableau de trace d'exĂ©cution.
En situation d'examen, vous devrez compléter une trace d'exécution sur papier sans utiliser d'ordinateur.
Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant les recettes de trace avec fonctions et avec conditions, complétez le tableau de trace d'exécution ligne par ligne.
def carre(x):
return x * x
def calcul(n):
if n % 2 == 0:
return n + 5
else:
return carre(n) - 1
x = 3
x = calcul(x)
if x >= 5:
calcul(x)
print("Hello World") if x == 13 else print("Fin")
Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.
Structures conditionnelles (if/else), définition et appel de fonctions, return, opérateur modulo (%), forme compacte (ternaire), trace d'exécution, débogueur
đŻ Solutionnaires
Consultez le solutionnaire uniquement aprĂšs avoir complĂ©tĂ© l'exercice par vous-mĂȘme.
Comparer votre réponse avec une solution vous permet de valider votre raisonnement et de corriger vos erreurs.
Consulter la solution avant d'avoir tenté l'exercice prive votre cerveau de l'occasion de construire des connexions durables.
- RĂ©vision : Trace avec fonction â solutionnaire.pdf
- Trace
while,if,breakâ solutionnaire.pdf - Trace
rangeimbriquĂ©,if,continueâ solutionnaire.pdf - Trace avec
if/else+ forme compacte â solutionnaire.pdf
âïž Exercices de comprĂ©hensionâ
Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.
TABpour indenter,Maj + TABpour retirer une indentation.- N'utilisez jamais la barre d'espace pour indenter.
- Toutes les lignes d'un mĂȘme bloc doivent avoir exactement la mĂȘme indentation.
- Sinon :
IndentationError.
đ CrĂ©ez un fichier r05_debogue_compte.md pour 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)
Boucle for avec range(), débogueur (compter les itérations, observer une variable), return
đ CrĂ©ez un fichier r05_evalue_expression.md pour votre rĂ©ponse.
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 5 (mettez un point d'arrĂȘt!) :
compteur * 2compteur > 3compteur % 2 == 0compteur + 100
total = 0
compteur = 0
for i in range(1, 6): # i â va valoir 1, 2, 3, 4 puis 5
total += i
compteur += 1
print(total)
print(compteur)
- Une fois la boucle terminée, que représente concrÚtement la valeur affichée aux lignes 6 et 7?
Rappel : total et compteur sont des variables accumulatrices : elles ne reçoivent pas une valeur fixe dÚs le départ, mais s'enrichissent à chaque passage dans la boucle. On les reconnaßt à leur initialisation à 0 avant la boucle et à l'opérateur += qui accumule les valeurs au fil des itérations.
DĂ©bogueur (« Evaluate Expression », point d'arrĂȘt), boucle for, opĂ©rateurs arithmĂ©tiques et logiques, modulo
đš Exercices de crĂ©ationâ
Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.
Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.
đ CrĂ©ez un fichier r05_aleatoire.py pour votre rĂ©ponse.
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.
Boucle (for), module random
đ CrĂ©ez un fichier r05_liste_aleatoire_boucle.py pour votre rĂ©ponse.
à la Rencontre #2, vous aviez rempli une liste avec cinq .append() copiés-collés, et un petit mot disait :
« une boucle ferait ça automatiquement⊠vous verrez ça bientÎt! ».
BientĂŽt, c'est maintenant. đ
PARTIE 1 - Construire la liste avec une boucleâ
- Partez d'une liste vide.
- à l'aide d'une boucle, ajoutez 10 nombres entiers aléatoires (entre 1 et 100 inclusivement) à la liste.
- Affichez la liste obtenue.
PARTIE 2 - Parcourir la liste par indexâ
- Parcourez la liste avec une boucle pour afficher chaque nombre sur sa propre ligne, prĂ©cĂ©dĂ© de « â ».
- Dans la mĂȘme logique de parcours, comptez combien de nombres sont supĂ©rieurs Ă 50 Ă l'aide d'une variable accumulatrice
compteur.
Utilisez une variable accumulatrice initialisée à 0 avant la boucle. à l'intérieur, une structure conditionnelle (if) vous permettra de décider à quel moment l'incrémenter.
â Exemple de sortie (les valeurs changent Ă chaque exĂ©cution)
Liste générée : [42, 7, 91, 55, 23, 88, 3, 67, 50, 12]
â 42
â 7
â 91
...
â 12
Nombres supérieurs à 50 : 4
đŻ Pour aller plus loinâ
Modifiez le programme pour générer non pas 10, mais 10 000 nombres, sans rien changer d'autre que ce nombre.
Construction d'une liste avec .append() dans une boucle, parcours par index, accumulateur de comptage, for + if, module random, généralisation
đ CrĂ©ez un fichier r05_umbrella_boucle.py pour votre rĂ©ponse.
à la Rencontre #3, vous aviez amélioré le rapport de l'Umbrella Corporation en créant une fonction afficher_echantillon(...) que vous appeliez 3 fois manuellement sur des listes parallÚles.
La promesse Ă©tait : « avec une boucle, un seul appel suffirait pour traiter tous les Ă©chantillons ». Tenons-la! đ§
đ ïž INSTRUCTIONSâ
- Recopier intégralement le code fait pour l'exercice (
r03_umbrella_corporation.py) dans le nouveau scriptr05_umbrella_boucle.py. - Ne modifiez pas la fonction
afficher_echantillon(...)(vous devez l'utiliser sans la modifier). - Remplacez les 3 appels manuels à la fonction par une seule boucle appelant la fonction avec les valeurs de l'échantillon correspondant à l'index
i.
Lorsqu'on exĂ©cute votre version, on doit observer exactement le mĂȘme rĂ©sultat que la version R3, mais avec un appel de fonction au lieu de trois.
đŻ Pour aller plus loinâ
Ajoutez un 4ᔠéchantillon dans les listes. Votre boucle doit l'afficher sans aucune autre modification au code. C'est ça, la puissance de combiner listes et boucles!
Boucle for, parcours de listes parallÚles par index, réutilisation et appel d'une fonction dans une boucle, généralisation via len()
đ CrĂ©ez un fichier r05_statistiques.py pour votre rĂ©ponse.
La corporation remarque des variations de la température dans l'une des salles d'entreposage.
Différentes mesures de la température ont été prises durant la journée :
temperatures = [23.5, 25.4, 27.6, 21.9, 26.7, 24.6]
Vous n'avez pas le droit d'utiliser des fonctions prĂ©dĂ©finies comme min(), max(), sum(), sort(), sorted(), ... (àČ„âŁàČ„).
Votre code doit fonctionner peu importe le nombre de mesures dans la liste.
PARTIE 1 : Compteur, somme et moyenneâ
Ă l'aide d'une boucle, calculez et affichez :
- le nombre de mesures prises
- la somme des températures
- la température moyenne
â RĂ©sultat attendu :
Températures : [23.5, 25.4, 27.6, 21.9, 26.7, 24.6]
nb. mesures : 6
somme : 149.7
moyenne : 24.95
- Compteur : utilisez une variable accumulatrice, comme vu précédemment, pour compter le nombre de températures.
- Somme : utilisez une variable accumulatrice, comme vu précédemment, pour faire la somme des températures.
- Moyenne : calculez-la aprÚs la boucle à partir des deux variables précédentes.
PARTIE 2 : Minimum et maximumâ
Ajoutez une deuxiÚme boucle pour calculer et afficher la température la plus basse et la plus élevée.
â RĂ©sultat attendu (en plus de la Partie 1) :
min : 21.9
max : 27.6
- Initialisez
min_tempetmax_tempavec le premier élément de la liste avant de démarrer la boucle. - à chaque itération, comparez la température courante avec
min_tempetmax_temp, et mettez-les à jour si nécessaire. - AprÚs la derniÚre itération,
min_tempetmax_tempcontiennent les valeurs recherchées.
đŻ Pour aller plus loinâ
Fusionnez vos deux boucles en une seule qui calcule les 5 statistiques en mĂȘme temps.
Boucle (for/while), parcours d'une liste, variables accumulatrices (compteur, somme), calcul de min/max sans fonction prédéfinie, structures conditionnelles, généralisation
đ CrĂ©ez un fichier r05_decimales.py pour votre rĂ©ponse.
à la Rencontre #2, vous avez découvert que les nombres flottants ne sont pas toujours exacts (0.1 + 0.2 donne 0.30000000000000004).
On va maintenant utiliser une boucle imbriquée pour observer ce phénomÚne à plus grande échelle.
Bob veut énumérer les décimales 0.1 à 0.9, puis 0.01 à 0.09, puis 0.001 à 0.009.
Il les calcule en multipliant un chiffre i (de 1 à 9) par une puissance de 10 négative :
for puissance in range(1, 4): # puissance vaut 1, puis 2, puis 3
for i in range(1, 10): # i vaut 1, 2, ..., 9
nombre = i * 10 ** -puissance
print(nombre, end=" ")
print() # saut de ligne aprĂšs chaque groupe
PARTIE 1 - Observerâ
Exécutez ce code et observez la sortie.
Repérez les nombres qui ne s'affichent pas exactement comme prévu (par exemple 0.30000000000000004 au lieu de 0.3).
PARTIE 2 - Comparer avec round()â
Modifiez la boucle pour afficher, à cÎté de chaque nombre, sa version arrondie avec round(nombre, puissance).
Pour chaque valeur, affichez aussi si les deux sont identiques ou non grĂące Ă une condition.
â Exemple de sortie (extrait)
0.1 â round: 0.1 â identique
0.2 â round: 0.2 â identique
0.30000000000000004 â round: 0.3 â DIFFĂRENT
0.4 â round: 0.4 â identique
đŻ Pour aller plus loinâ
- Augmentez la portĂ©e pour aller jusqu'Ă
0.000000001en changeant une seule valeur dans votre code. - Bob a essayĂ© une autre mĂ©thode pour gĂ©nĂ©rer les mĂȘmes dĂ©cimales :
au lieu de multiplier, il construit une chaĂźne de caractĂšres puis la convertit enfloat.
Remplacez la ligne 3 (nombre = i * 10 ** -puissance) par :
nombre = float("0." + "0" * (puissance - 1) + str(i))
Reprenez votre comparaison de la Partie 2 avec cette mĂ©thode. Que remarquez-vous? Y a-t-il encore des nombres marquĂ©s « DIFFĂRENT »?
đĄ Cela illustre une idĂ©e importante : la prĂ©cision dĂ©pend de la façon dont on calcule une valeur, pas seulement de la valeur elle-mĂȘme.
Boucles imbriquĂ©es (for), range(), opĂ©rateur de puissance (**), prĂ©cision des flottants, round(), structure conditionnelle, end dans print(), conversion str â float
đ CrĂ©ez un fichier r05_devine.py pour votre rĂ©ponse.
Ă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!"
Pour ce numéro, vous devez utiliser la fonction input() et int().
Il est possible d'utiliser ces fonctions à l'intérieur d'une boucle!
Lorsque la fonction input(...) est exécutée, le programme se met en pause.
Le programme attend que l'utilisateur.rice Ă©crive quelque chose dans la console et qu'il ou elle appuie sur la touche ENTRĂE.
C'est donc normal que l'instruction suivante ne soit pas exécutée tant que vous n'avez pas saisi quelque chose dans la console!
Boucle while, module random, input(), int(), structures conditionnelles, condition d'arrĂȘt
đ CrĂ©ez un fichier r05_refactorisation_bulletins.py pour votre rĂ©ponse.
Le code ci-dessous affiche un mini-bulletin pour un.e étudiant.e.
Il fonctionne correctement, mais il est truffé de répétitions inutiles dans les blocs if/elif/else.
Votre mission : le réécrire proprement en appliquant le principe DRY.
nom = "Félix"
note = 72
if note >= 90:
print("=== Bulletin scolaire ===")
print(f"Ătudiant : {nom}")
print(f"Note : {note} %")
print("Mention : Excellent")
print("Félicitations!")
print("=========================")
elif note >= 75:
print("=== Bulletin scolaire ===")
print(f"Ătudiant : {nom}")
print(f"Note : {note} %")
print("Mention : Bien")
print("Félicitations!")
print("=========================")
elif note >= 60:
print("=== Bulletin scolaire ===")
print(f"Ătudiant : {nom}")
print(f"Note : {note} %")
print("Mention : Passable")
print("Bonne continuation.")
print("=========================")
else:
print("=== Bulletin scolaire ===")
print(f"Ătudiant : {nom}")
print(f"Note : {note} %")
print("Mention : Ăchec")
print("Bonne continuation.")
print("=========================")
đ ïž INSTRUCTIONSâ
-
Identifiez toutes les instructions redondantes dans le code ci-dessus :
Comptez combien de fois chaqueprintapparaĂźt. Lesquels se retrouvent dans les 4 blocs? Lesquels varient d'un bloc Ă l'autre? -
Créez une fonction
afficher_bulletin(nom, note)qui réécrit ce code proprement, sans répétition.
Validez votre fonction avec ces deux appels :afficher_bulletin("Félix", 72)afficher_bulletin("Dayron", 91)
â Sortie attendue
=== Bulletin scolaire ===
Ătudiant : FĂ©lix
Note : 72 %
Mention : Passable
Bonne continuation.
=========================
=== Bulletin scolaire ===
Ătudiant : Dayron
Note : 91 %
Mention : Excellent
Félicitations!
=========================
Refactorisation (principe DRY), structures conditionnelles (if/elif/else), définition de fonction, f-strings
đ CrĂ©ez un fichier r05_generer_nombre.py pour votre rĂ©ponse.
Le code de la fonction ci-dessous permet de générer un nombre de 3 chiffres (sans zéro) :
import random
def generer_nombre():
nombre = 0
position = 0
chiffre_aleatoire = random.randint(1, 9)
nombre += chiffre_aleatoire * 10 ** position # 10**0 = 1
position = 1
chiffre_aleatoire = random.randint(1, 9)
nombre += chiffre_aleatoire * 10 ** position # 10**1 = 10
position = 2
chiffre_aleatoire = random.randint(1, 9)
nombre += chiffre_aleatoire * 10 ** position # 10**2 = 100
return nombre
resultat = generer_nombre()
print(f"Nombre généré : {resultat}")
- Modifier le code afin de retirer la répétition de code (à l'aide d'une boucle).
- Ajouter un paramÚtre optionnel à la fonction pour indiquer la longueur du nombre à générer (par défaut 3).
Boucles (for/while), refactorisation (DRY), définition de fonction, paramÚtre avec valeur par défaut, module random, opérateurs arithmétiques (puissances de 10)
đ CrĂ©ez un fichier r05_etoile_1.py pour votre rĂ©ponse.
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!
Boucles imbriquées (for), affichage sans saut de ligne (end), identification de répétitions, généralisation d'un motif
âïž Exercices sur papierâ
Faites ces exercices d'abord sur papier (ou dans un éditeur de texte simple) et sans aucune documentation, comme à l'examen.
Vous pouvez valider votre rĂ©ponse dans PyCharm Ă la fin â un luxe que vous n'aurez pas le jour de l'examen, d'oĂč l'importance de vous entraĂźner sans lui.
đ CrĂ©ez un fichier r05_cote_passage.py pour votre rĂ©ponse.
Une liste de notes est déjà déclarée dans votre programme :
notes = [72, 45, 88, 55, 91, 60, 38]
Ăcrivez le reste du programme qui parcourt cette liste et affiche, pour chaque note, si l'Ă©tudiant a rĂ©ussi (â„ 60) ou Ă©chouĂ©. Ă la fin, affichez le nombre total de rĂ©ussites.
Exemple de sortie attendu :
72 â RĂ©ussi
45 â ĂchouĂ©
88 â RĂ©ussi
55 â ĂchouĂ©
91 â RĂ©ussi
60 â RĂ©ussi
38 â ĂchouĂ©
Nombre de réussites : 4
Boucle for sur une liste, if/else, variable accumulatrice, f-string
đŻ 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Ă©bogueur 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 comprĂ©hension :
- DĂ©bogue et compte â solutionnaire.pdf
- Evalue une expression â solutionnaire.pdf
đš Solution des exercices de crĂ©ation :
- Afficher 5 chiffres aléatoires
- Remplir et analyser une liste
- Umbrella Corporation, version boucle
- Calculer des statistiques
- ĂnumĂ©rer des dĂ©cimales (solutionnaire Ă venir)
- Jeu de devinette numérique
- Refactorisation : les bulletins scolaires
- Générer un nombre - DRY : boucle simple
- Affichage d'étoiles - DRY : boucle imbriquée
âïž Solution des exercices sur papier :