đ Conditions et boucle while
- Expressions booléennes
- if
- elif
- else
- if ou elif?
- Imbrication
- raise
- Affectation
- while
- Trace
- Activités
- *match/case*
Une expression booléenne est une expression qui s'évalue à une valeur de vérité (bool), c'est-à -dire soit True (vrai), soit False (faux).
Elles servent à prendre des décisions dans le code : dans les structures conditionnelles (if, elif) et dans les boucles while.
- Les opérateurs de comparaison (
==,!=,<,>,<=,>=) comparent deux valeurs. - Les opérateurs logiques (
and,or,not) combinent plusieurs expressions booléennes.
OpĂ©rateurs de comparaisonâ
| Opérateur | Description | Exemple | Résultat |
|---|---|---|---|
| == | Ăgal Ă | a == b | True si Ă©gaux |
| != | Différent de | a != b | True si différents |
| < | Inférieur à | a < b | True si a plus petit |
| <= | Inférieur ou égal à | a <= b | True si a plus petit ou égal |
| > | Supérieur à | a > b | True si a plus grand |
| >= | Supérieur ou égal à | a >= b | True si a plus grand ou égal |
OpĂ©rateurs logiquesâ
| Opérateur | Description | Exemple | Résultat |
|---|---|---|---|
| and | ET logique | a and b | True si les deux sont True |
| or | OU logique | a or b | True si au moins un est True |
| not | NON logique | not a | Inverse la valeur booléenne |
= et ===affecte une valeur à une variable :x = 5(« x reçoit 5 »).==compare deux valeurs :x == 5(« x est-il égal à 5? »), ce qui donneTrueouFalse.
if x = 5: # â SyntaxError : on ne peut pas affecter dans une condition
if x == 5: # â
On compare
a = 5
b = 10
print(a < b) # Affiche True
print(a == b) # Affiche False
print(a + 5 >= b * 2 - 12) # Affiche True, explications ci-dessous!
Les deux opĂ©randes d'un opĂ©rateur de comparaison peuvent ĂȘtre le rĂ©sultat d'autres expressions.
Python évalue l'expression selon la priorité des opérateurs, en remplaçant chaque sous-expression par sa valeur.
Voici comment Python évalue l'instruction de la ligne 5, étape par étape :
print(a + 5 >= b * 2 - 12) # Instruction originale
print(5 + 5 >= b * 2 - 12) # Remplace 'a' par sa valeur
print(10 >= b * 2 - 12) # Calcule la somme 5 + 5
print(10 >= 10 * 2 - 12) # Remplace 'b' par sa valeur
print(10 >= 20 - 12) # La multiplication passe avant la soustraction
print(10 >= 8) # Calcule la soustraction
print(True) # La comparaison est faite en dernier
Les opérateurs logiques combinent des expressions booléennes. Leur résultat ne dépend que des valeurs True/False qu'on leur donne :
A | B | A and B | A or B | not A |
|---|---|---|---|---|
True | True | True | True | False |
True | False | False | True | False |
False | True | False | True | True |
False | False | False | False | True |
anddonneTrueseulement si les deux sontTrue.ordonneTruesi au moins un estTrue.notinverse la valeur.
Exemple : une solution est acide si son pH est d'au moins 0 et plus petit que 7.
ph = 4.2
est_acide = ph >= 0 and ph < 7
print(est_acide) # True (True and True)
print(not est_acide) # False
En Python, on peut enchaßner les comparaisons comme en mathématiques :
print(0 <= ph < 7) # Ăquivalent Ă : ph >= 0 and ph < 7
C'est trÚs pratique pour vérifier qu'une valeur est dans un intervalle, par exemple 0 < n < 1.
print(0.1 + 0.2 == 0.3) # False!
print(round(0.1 + 0.2, 2) == 0.3) # True
Les nombres à virgule (float) ne sont pas toujours représentés exactement (voir l'onglet Précision des flottants de la rencontre 2).
Pour comparer des float, arrondissez-les d'abord à la précision voulue.
La priorité des opérateurs détermine l'ordre dans lequel les opérations sont effectuées dans une expression.
En Python, la priorité est la suivante (de la plus haute à la plus basse) :
- ParenthĂšses
() - Opérateurs arithmétiques (
**, puis*,/,//,%, puis+,-) - Opérateurs de comparaison (
==,!=,<,<=,>,>=) - Opérateur
not - Opérateur
and - Opérateur
or
Un ordre plus exhaustif des priorités des opérateurs est disponible ici dans l'aide-mémoire.
a = 5
b = 10
c = 15
print(a < b and b < c) # ĂvaluĂ© comme (a < b) and (b < c), affiche True
print(a < b or b > c) # ĂvaluĂ© comme (a < b) or (b > c), affiche True
print(not a < b) # ĂvaluĂ© comme not (a < b), affiche False
# Les parenthÚses peuvent changer le résultat :
print(a > b and b > c or a == 5) # (False and False) or True â True
print(a > b and (b > c or a == 5)) # False and (False or True) â False
Sans parenthÚses, le and est évalué avant le or. En cas de doute, ajoutez des parenthÚses : votre code sera aussi plus facile à lire.
On peut stocker le résultat d'une expression booléenne dans une variable pour une utilisation ultérieure.
a = 5
b = 10
est_plus_petit = a < b # est_plus_petit sera True
est_egal = a == b # est_egal sera False
print(est_plus_petit) # Affiche True
print(est_egal) # Affiche False
Les explications de cette section étaient-elles claires ?
C'est bien beau, ça, les expressions booléennes, mais à quoi ça sert?
đ Elles servent principalement Ă contrĂŽler le flux d'exĂ©cution du programme,
c'est-Ă -dire Ă dĂ©cider quelles parties du code doivent ĂȘtre exĂ©cutĂ©es en fonction de certaines conditions.
Voici un exemple simple d'instruction conditionnelle en Python :
age = 18
if age >= 18:
print("Vous ĂȘtes majeur.")
Dans cet exemple, l'instruction if vérifie si la variable age est supérieure ou égale à 18.
Si c'est le cas (si la condition est True), le code indentĂ© sous l'instruction if est exĂ©cutĂ©, affichant "Vous ĂȘtes majeur.".
Si la condition est False, le code indenté n'est pas exécuté.
Exécutez ce code en mode débogage avec age = 18, puis avec age = 15 : avancez une ligne à la fois et observez que la ligne 3 est sautée quand la condition est fausse.
En Python, l'indentation (les espaces ou tabulations avant une ligne de code) est cruciale pour définir les blocs de code.
Le code qui doit ĂȘtre exĂ©cutĂ© conditionnellement doit ĂȘtre indentĂ© sous l'instruction if.
Par exemple :
if condition:
# Code indenté, exécuté si la condition est True
faire_quelque_chose_conditionnel()
faire_autre_chose_conditionnel()
# Code non indenté, exécuté indépendamment de la condition
faire_autre_chose_en_tout_temps()
Exemple d'erreur courante due Ă une mauvaise indentation :
if condition:
faire_quelque_chose() # Erreur : cette ligne doit ĂȘtre indentĂ©e
Autre erreur fréquente : oublier le deux-points à la fin de la ligne du if.
if age >= 18 # â SyntaxError: expected ':'
print("Vous ĂȘtes majeur.")
Exemple concret :
age = 20
if age >= 18:
print("Vous ĂȘtes majeur.")
print("Vous avez le droit de vote!")
print("Un grand pouvoir implique de grandes responsabilités.")
print("Bienvenue!") # Toujours exécuté, indépendamment de l'ùge
Les explications de cette section étaient-elles claires ?
Non!
elif est la contraction de "else if", qui signifie "sinon si".
Elle permet de vérifier une autre condition si la premiÚre condition dans l'instruction if est False.
Par exemple :
age = 16
if age >= 18:
print("Vous ĂȘtes majeur.")
elif age >= 13:
print("Vous ĂȘtes adolescent.")
On peut avoir plusieurs clauses elif pour vérifier plusieurs conditions différentes.
Par exemple :
age = 10
if age >= 18:
print("Vous ĂȘtes majeur.")
elif age >= 13:
print("Vous ĂȘtes adolescent.")
elif age >= 3:
print("Vous ĂȘtes un enfant.")
Que se passe-t-il avec age = 2? Aucune condition n'est vraie : aucun bloc n'est exécuté et rien n'est affiché.
Pour prévoir un bloc exécuté « dans tous les autres cas », on utilise else (onglet suivant).
L'ordre des conditions est important.
Les conditions sont évaluées de haut en bas, et la premiÚre condition qui est True déclenche l'exécution du bloc de code correspondant.
Par exemple, dans le code suivant, la condition age >= 13 sera toujours True pour tous les adultes, et la condition age >= 18 ne sera jamais atteinte :
age = 21
if age >= 13:
print("Vous ĂȘtes adolescent.")
elif age >= 18:
print("Vous ĂȘtes majeur.")
Pour Ă©viter cela, placez les conditions du cas le plus prĂ©cis au cas le plus gĂ©nĂ©ral : ici, age >= 18 est plus prĂ©cis que age >= 13 (tous les majeurs ont aussi au moins 13 ans), il doit donc ĂȘtre vĂ©rifiĂ© en premier :
age = 21
if age >= 18:
print("Vous ĂȘtes majeur.")
elif age >= 13:
print("Vous ĂȘtes adolescent.")
đ Avec <, l'ordre s'inverse : on commence par la plus petite borne (if age < 3, puis elif age < 13, puis elif age < 18).
elif sans ifUne clause elif doit toujours ĂȘtre prĂ©cĂ©dĂ©e d'une instruction if.
Par exemple, le code suivant est incorrect et provoquera une erreur de syntaxe :
age = 16
elif age >= 13: # Erreur : 'elif' sans 'if'
print("Vous ĂȘtes adolescent.")
Les explications de cette section étaient-elles claires ?
else signifie "sinon".
Elle permet de définir un bloc de code qui sera exécuté si toutes les conditions précédentes (if et elif) sont False.
Par exemple :
age = 10
if age >= 18:
print("Vous ĂȘtes majeur.")
elif age >= 13:
print("Vous ĂȘtes adolescent.")
else:
print("Vous ĂȘtes un enfant.")
Dans cet exemple, si age est infĂ©rieur Ă 13, le message "Vous ĂȘtes un enfant." sera affichĂ©.
La clause else est souvent utilisée à la fin d'une série d'instructions if et elif pour capturer tous les cas non couverts par les conditions précédentes.
Par exemple :
score = 85
if score >= 90:
print("Excellent")
elif score >= 75:
print("Bien")
elif score >= 50:
print("Passable")
else:
print("Ăchec")
Contrairement Ă if et elif, la clause else ne prend pas de condition.
Elle est simplement exécutée si toutes les conditions précédentes sont False. Par exemple, le code suivant est incorrect et provoquera une erreur de syntaxe :
score = 85
if score >= 90:
print("Excellent")
elif score >= 75:
print("Bien")
elif score >= 50:
print("Passable")
else score < 50: # Erreur : 'else' ne doit pas avoir de condition
print("Ăchec")
Il est possible d'utiliser else directement aprĂšs un if, sans avoir besoin de elif.
Par exemple :
age = 20
if age >= 18:
print("Vous ĂȘtes majeur.")
else:
print("Vous ĂȘtes mineur.")
Les structures conditionnelles (if/elif/else, match/case) peuvent ĂȘtre utilisĂ©es Ă l'intĂ©rieur de fonctions.
Exemple 1 â if/else simple :
def est_pair(n):
if n % 2 == 0:
return True # Faire modulo 2 sur un nombre pair donne toujours 0!
else:
return False
a = 33
b = 52
print(f"{a} est un nombre pair : {est_pair(a)}")
print(f"{b} est un nombre pair : {est_pair(b)}")
33 est un nombre pair : False
52 est un nombre pair : True
đĄ Puisque n % 2 == 0 donne dĂ©jĂ True ou False, on peut retourner directement le rĂ©sultat de la comparaison :
def est_pair(n):
return n % 2 == 0
Exemple 2 â if avec paramĂštre optionnel et calcul par palier :
La fonction suivante calcule la paie brute d'un employé. Elle accepte un troisiÚme paramÚtre optionnel pour activer le calcul des heures supplémentaires au taux double.
def calculer_paie_brute(nb_heures, taux_horaire, temps_double_apres_40_heures=False):
salaire = nb_heures * taux_horaire
if temps_double_apres_40_heures and nb_heures >= 40:
nb_heures_temps_supp = nb_heures - 40
salaire = salaire + nb_heures_temps_supp * taux_horaire * 2
return salaire
nb_heures = 45
taux_horaire = 20
print(f"Calcul de la paie brute pour {nb_heures} heures Ă un taux horaire de {taux_horaire}$/h.")
print(f" Avec le temps > 40 payé au taux doublé : {calculer_paie_brute(nb_heures, taux_horaire, True)}$")
print(f" Avec le temps > 40 payé au taux régulier : {calculer_paie_brute(nb_heures, taux_horaire)}$")
Calcul de la paie brute pour 45 heures Ă un taux horaire de 20$/h.
Avec le temps > 40 payé au taux doublé : 1100$
Avec le temps > 40 payé au taux régulier : 900$
Exemple 3 â if/elif/else avec trois listes parallĂšles :
On peut stocker plusieurs valeurs dans des listes parallĂšles et appeler notre fonction sur chaque Ă©lĂ©ment. Voici une liste d'Ă©lĂ©ments du tableau pĂ©riodique avec leur masse atomique (en u.m.a.) et leur nombre de protons. On veut classifier la stabilitĂ© de chaque noyau en fonction du rapport entre sa masse atomique et son nombre de protons â un indicateur simplifiĂ© du ratio neutrons/protons :
def stabilite_noyau(masse_atomique, nb_protons):
"""
Classifie la stabilité d'un noyau selon le ratio neutrons/protons.
ParamĂštres :
masse_atomique (int) : Nombre de masse de l'élément (protons + neutrons).
nb_protons (int) : Nombre de protons dans le noyau.
Retourne :
str : "stable", "légÚrement instable" ou "trÚs instable".
"""
nb_neutrons = masse_atomique - nb_protons
ratio = nb_neutrons / nb_protons
if ratio <= 1.1:
return "stable"
elif ratio <= 1.5:
return "légÚrement instable"
else:
return "trĂšs instable"
masses_atomiques = [1,4,7,12,14,16]
symboles = ["H","He","Li","C","N","O"]
nb_protons = [1,2,3,6,7,8]
print(f"{symboles[0]} (masse {masses_atomiques[0]}) - stabilité : {stabilite_noyau(masses_atomiques[0], nb_protons[0])}")
print(f"{symboles[1]} (masse {masses_atomiques[1]}) - stabilité : {stabilite_noyau(masses_atomiques[1], nb_protons[1])}")
print(f"{symboles[2]} (masse {masses_atomiques[2]}) - stabilité : {stabilite_noyau(masses_atomiques[2], nb_protons[2])}")
print(f"{symboles[3]} (masse {masses_atomiques[3]}) - stabilité : {stabilite_noyau(masses_atomiques[3], nb_protons[3])}")
print(f"{symboles[4]} (masse {masses_atomiques[4]}) - stabilité : {stabilite_noyau(masses_atomiques[4], nb_protons[4])}")
print(f"{symboles[5]} (masse {masses_atomiques[5]}) - stabilité : {stabilite_noyau(masses_atomiques[5], nb_protons[5])}")
H (masse 1) - stabilité : stable
He (masse 4) - stabilité : stable
Li (masse 7) - stabilité : légÚrement instable
C (masse 12) - stabilité : stable
N (masse 14) - stabilité : stable
O (masse 16) - stabilité : stable
đ On remarque qu'on rĂ©pĂšte 6 fois la mĂȘme instruction print en changeant seulement l'index.
C'est exactement le genre de répétition qu'une boucle for éliminera en quelques lignes, vous verrez ça bientÎt!
Les explications de cette section étaient-elles claires ?
if if if vs if elif else â ce n'est pas la mĂȘme chose!C'est l'une des erreurs les plus frĂ©quentes chez les dĂ©butants :
utiliser plusieurs if indĂ©pendants lĂ oĂč un if/elif/else serait nĂ©cessaire.
La différence est fondamentale : le programme peut afficher un résultat faux.
Prenons cet exemple avec score = 95 :
# Version avec des if if if
score = 95
if score >= 90:
print("Excellent") # â
Exécuté (95 >= 90 est True)
if score >= 75:
print("Bien") # â
Exécuté (95 >= 75 est True)
if score >= 50:
print("Passable") # â
Exécuté (95 >= 50 est True)
else:
print("Ăchec") # âïž Bloc ignorĂ© (car la condition score >= 50 a donnĂ© True)
Résultat affiché :
Excellent
Bien
Passable
đ Avec des if indĂ©pendants, Python Ă©value chaque condition sĂ©parĂ©ment, de haut en bas, sans jamais s'arrĂȘter. Comme les 3 conditions sont True pour score = 95, les 3 blocs sont exĂ©cutĂ©s. Ce n'est presque certainement pas ce qu'on voulait! Il aurait Ă©tĂ© prĂ©fĂ©rable que Python arrĂȘte dâĂ©valuer les autres conditions dĂšs quâil trouve une condition donnant True.
if elif else# Version avec if elif else
score = 95
if score >= 90:
print("Excellent") # â
ExĂ©cutĂ© (95 >= 90 est True) â Python arrĂȘte ici
elif score >= 75:
print("Bien") # âïž Bloc ignorĂ© (car une condition d'un bloc prĂ©cĂ©dent a donnĂ© True)
elif score >= 50:
print("Passable") # âïž Bloc ignorĂ© (car une condition d'un bloc prĂ©cĂ©dent a donnĂ© True)
else:
print("Ăchec") # âïž Bloc ignorĂ© (car une condition d'un bloc prĂ©cĂ©dent a donnĂ© True)
Résultat affiché :
Excellent
đ Avec if/elif/else, dĂšs qu'une condition est True, Python exĂ©cute le bloc correspondant et saute immĂ©diatement le reste : les autres conditions ne sont jamais Ă©valuĂ©es. Un seul bloc s'exĂ©cute, peu importe le nombre de elif. Python a donc exĂ©cutĂ© uniquement le bloc associĂ© Ă score >= 90.
| Situation | Utiliser |
|---|---|
| Les cas sont mutuellement exclusifs (un seul doit s'exécuter) | if / elif / else |
| Les vérifications sont indépendantes les unes des autres | Plusieurs if séparés |
Exemple oĂč plusieurs if sĂ©parĂ©s sont appropriĂ©s :
ph = 3.5
temperature_celsius = 85
pression_atm = 1.8
if ph < 6:
print("â ïž Solution acide : portez des gants de protection.") # â
Exécuté
if temperature_celsius > 60:
print("đĄïž TempĂ©rature Ă©levĂ©e : risque de brĂ»lure.") # â
Exécuté
if pression_atm > 1.5:
print("đš Pression Ă©levĂ©e : vĂ©rifiez l'Ă©tanchĂ©itĂ© du systĂšme.") # â
Exécuté
Ici, les 3 avertissements sont complémentaires et ont du sens ensemble. Plusieurs if indépendants sont donc le bon choix.
Pour récapituler, la structure d'une instruction conditionnelle en Python est la suivante :
if: Obligatoire pour commencer une instruction conditionnelle.elif: Les blocselifsont optionnels.- Il peut y en avoir 0, 1, 2 ou plus.
- Chaque
elifvérifie une condition, seulement si toutes les conditions précédentes sontFalse.
else: Le blocelseest optionnel.- Il ne peut y avoir quâun seul
else. - Il est exécuté si toutes les conditions précédentes sont
False. - Le bloc
elsene prend pas de condition.
- Il ne peut y avoir quâun seul
- Les conditions sont évaluées de haut en bas : dÚs qu'une condition est
True, son bloc est exĂ©cutĂ© et les suivantes sont ignorĂ©es. - Le code de chaque bloc doit ĂȘtre indentĂ© sous la ligne
if,elifouelsecorrespondante.
Les explications de cette section étaient-elles claires ?
Il est tout à fait possible d'écrire une structure conditionnelle à l'intérieur d'une autre.
On appelle cela des structures imbriquées (nested en anglais).
C'est utile quand une décision dépend d'une autre, comme dans la vraie vie!
Imaginons qu'on veuille classer un échantillon selon son pH ET sa température :
ph = 4.2
temperature_celsius = 75
if ph < 7:
print("Solution acide.")
if temperature_celsius > 60: # Condition imbriquée dans le if
print("â ïž Acide ET chaude : danger!")
else:
print("Acide mais à température normale.")
else:
print("Solution neutre ou basique.")
if temperature_celsius > 60: # Condition imbriquée dans le else
print("â ïž Solution chaude : manipuler avec prĂ©caution.")
else:
print("Conditions stables.")
Résultat affiché avec ph = 4.2 et temperature_celsius = 75 :
Solution acide.
â ïž Acide ET chaude : danger!
đ Python entre d'abord dans le bloc if ph < 7, puis Ă©value la condition sur la tempĂ©rature seulement Ă l'intĂ©rieur de ce bloc.
Chaque niveau d'imbrication ajoute un niveau d'indentation supplémentaire.
C'est ce qui permet Ă Python de savoir Ă quel bloc appartient chaque instruction.
if condition_1:
# Bloc de la condition 1 (indenté 1 fois)
if condition_2:
# Bloc de la condition 2 (indenté 2 fois)
faire_quelque_chose()
else:
# Bloc else de la condition 2 (indenté 2 fois)
faire_autre_chose()
else:
# Bloc else de la condition 1 (indenté 1 fois)
faire_encore_autre_chose()
En astronomie, on peut classer une étoile selon sa luminosité et sa température de surface :
luminosite = 500 # En unités solaires
temperature_K = 8000 # En kelvins
if luminosite >= 100:
print("Ătoile trĂšs lumineuse.")
if temperature_K >= 10000:
print("â Classification : Ă©toile bleue gĂ©ante.")
elif temperature_K >= 6000:
print("â Classification : Ă©toile blanche gĂ©ante.")
else:
print("â Classification : supergĂ©ante froide.")
elif luminosite >= 1:
print("Ătoile de luminositĂ© moyenne.")
if temperature_K >= 6000:
print("â Classification : Ă©toile de la sĂ©quence principale (type solaire ou plus chaud).")
else:
print("â Classification : Ă©toile naine froide.")
else:
print("Ătoile peu lumineuse.")
if temperature_K >= 4000:
print("â Classification : naine blanche.")
else:
print("â Classification : naine brune.")
Résultat affiché avec luminosite = 500 et temperature_K = 8000 :
Ătoile trĂšs lumineuse.
â Classification : Ă©toile blanche gĂ©ante.
đ Le premier if/elif/else traite la luminositĂ©, puis, Ă l'intĂ©rieur de chacun de ses blocs, un second if/elif/else affine la classification selon la tempĂ©rature.
if/else seul dans un else? Utilisez elif!Quand le bloc else ne contient qu'un if/else, on peut le remplacer par un elif et retirer un niveau d'indentation :
# Imbriqué
if ph < 7:
print("Acide")
else:
if ph == 7:
print("Neutre")
else:
print("Basique")
# Ăquivalent, plus lisible
if ph < 7:
print("Acide")
elif ph == 7:
print("Neutre")
else:
print("Basique")
đ L'imbrication est utile quand le bloc contient autre chose que la condition imbriquĂ©e (comme le print("Solution acide.") de l'exemple de base).
Plus on imbrique de niveaux, plus le code devient difficile à lire et à déboguer.
En général, une bonne rÚgle de base est de ne pas dépasser 2 à 3 niveaux.
Si vous vous retrouvez avec plus de 3 niveaux, c'est souvent le signe que le code pourrait ĂȘtre rĂ©organisĂ©, par exemple en utilisant des fonctions.
# â Difficile Ă lire â trop de niveaux d'imbrication
if condition_1:
if condition_2:
if condition_3:
if condition_4:
faire_quelque_chose() # On s'y perd!
# â
Plus lisible â on peut souvent combiner les conditions avec and
if condition_1 and condition_2 and condition_3 and condition_4:
faire_quelque_chose()
| Situation | Approche recommandée |
|---|---|
| La 2e condition ne s'évalue que si la 1re est vraie | Imbrication |
| Les conditions sont indépendantes les unes des autres | Plusieurs if séparés |
| Les conditions peuvent ĂȘtre combinĂ©es simplement | and / or dans un seul if |
đ L'imbrication est le bon choix quand la logique est hiĂ©rarchique : on vĂ©rifie d'abord une catĂ©gorie gĂ©nĂ©rale, puis on affine Ă l'intĂ©rieur de cette catĂ©gorie.
Les explications de cette section étaient-elles claires ?
Quand on écrit une fonction, il faut s'assurer que les entrées (paramÚtres) ont du sens.
Sinon, on risque d'obtenir des résultats absurdes ou des erreurs difficiles à comprendre.
Comparez ces deux versions :
# Version 1 â sans validation
def vitesse_moyenne(distance, temps):
return distance / temps
print(vitesse_moyenne(100, 20)) # â
5.0
print(vitesse_moyenne(-50, 10)) # â ïž -5.0 m/s sans avertissement (rĂ©sultat absurde), le programme continue malgrĂ© tout!
print(vitesse_moyenne(100, 0)) # â Erreur Python brute (ZeroDivisionError: division by zero), le programme arrĂȘte ici!
# Version 2 â avec validation
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
print(vitesse_moyenne(100, 20)) # â
5.0
print(vitesse_moyenne(-50, 10)) # â ValueError: La distance ne peut pas ĂȘtre nĂ©gative. Message clair, le programme arrĂȘte ici!
print(vitesse_moyenne(100, 0)) # Jamais atteint : le programme s'est arrĂȘtĂ© Ă la ligne prĂ©cĂ©dente
đ La version 2 donne des messages d'erreur explicites, Ă©vite les rĂ©sultats absurdes et rend le code plus robuste et rĂ©utilisable.
raise â mettre une barriĂšre dans une fonctionraise permet de provoquer volontairement une erreur lorsqu'une condition n'est pas respectĂ©e.
C'est la façon de signaler au programmeur qui appelle la fonction qu'il l'utilise avec de mauvaises valeurs.
Dans la version 2 de vitesse_moyenne :
- chaque
ifvérifie une contrainte sur les paramÚtres; - si la contrainte n'est pas respectée,
raiselÚve une exception avec un message qui explique le problÚme; - Python interrompt immédiatement la fonction (comme un
return) : les lignes suivantes, dont le calcul, ne sont jamais exécutées.
Quand une exception n'est pas attrapée, Python affiche un bloc rouge appelé traceback. Il se lit de bas en haut. Voici celui obtenu avec la version 2 de vitesse_moyenne ci-dessus :
Traceback (most recent call last):
File "...\r04_vitesse.py", line 12, in <module>
print(vitesse_moyenne(-50, 10))
~~~~~~~~~~~~~~~^^^^^^^^^
File "...\r04_vitesse.py", line 4, in vitesse_moyenne
raise ValueError("La distance ne peut pas ĂȘtre nĂ©gative.")
ValueError: La distance ne peut pas ĂȘtre nĂ©gative.
- La derniĂšre ligne donne le type d'exception (
ValueError) et le message : c'est ce qu'il faut lire en premier. - Juste au-dessus : la ligne qui a levé l'exception (ligne 4, dans la fonction
vitesse_moyenne). - Plus haut : d'oĂč la fonction a Ă©tĂ© appelĂ©e (ligne 12). C'est souvent lĂ que se trouve la cause, ici une distance nĂ©gative passĂ©e en argument.
đ C'est pour ça qu'un message utile dans raise est si important : c'est la premiĂšre chose que lira la personne qui utilise votre fonction.
Pour vérifier qu'une valeur est comprise entre deux bornes, on combine not et une comparaison enchaßnée :
def classer_solution(ph):
if not 0 <= ph <= 14:
raise ValueError("Le pH doit ĂȘtre compris entre 0 et 14.")
if ph < 7:
return "acide"
elif ph == 7:
return "neutre"
else:
return "basique"
print(classer_solution(4.2)) # acide
print(classer_solution(15)) # â ValueError: Le pH doit ĂȘtre compris entre 0 et 14.
0 <= ph <= 14 est True si le pH est valide; not inverse le résultat pour lever l'exception seulement quand il est hors de l'intervalle.
Avec raise, une erreur arrĂȘte le programme avec un message clair : c'est voulu, puisque la fonction a Ă©tĂ© mal utilisĂ©e.
Ă la rencontre 5, vous verrez comment attraper une erreur avec try/except pour que le programme puisse continuer.
isinstancePour une validation solide, on peut aussi vĂ©rifier que les paramĂštres sont du bon type avant mĂȘme de vĂ©rifier leur valeur.
def calculer_concentration(masse_g, volume_L):
if not (isinstance(masse_g, int) or isinstance(masse_g, float)):
raise TypeError("La masse doit ĂȘtre un nombre (int ou float).")
if not (isinstance(volume_L, int) or isinstance(volume_L, float)):
raise TypeError("Le volume doit ĂȘtre un nombre (int ou float).")
if masse_g < 0:
raise ValueError("La masse ne peut pas ĂȘtre nĂ©gative.")
if volume_L <= 0:
raise ValueError("Le volume doit ĂȘtre supĂ©rieur Ă 0.")
return masse_g / volume_L
print(calculer_concentration(10, 2)) # â
5.0
print(calculer_concentration(10, "a")) # â TypeError: Le volume doit ĂȘtre un nombre (int ou float).
print(calculer_concentration(-5, 2)) # Jamais atteint : le programme s'est arrĂȘtĂ© Ă la ligne prĂ©cĂ©dente
La fonction isinstance(valeur, type) retourne True si la valeur est du type donné.
Par exemple : isinstance(5, int) â True, isinstance("5", int) â False.
Pour accepter plusieurs types (ici int ou float), on combine deux appels avec or, puis on inverse le tout avec not : la condition est vraie seulement si la valeur n'est ni un int, ni un float.
đ On valide d'abord les types, puis les valeurs : une masse de type str ne pourrait mĂȘme pas ĂȘtre comparĂ©e Ă 0 sans provoquer une erreur.
Nous nous limitons aux trois exceptions les plus courantes :
| Exception | Quand l'utiliser |
|---|---|
| TypeError | Le type de la valeur n'est pas celui attendu (ex. : un texte au lieu d'un nombre) |
| ValueError | La valeur est du bon type, mais ne respecte pas une contrainte (ex. : masse négative, pH hors de 0 à 14) |
| ZeroDivisionError | La valeur vaut exactement 0 et sert de dénominateur dans un calcul |
đ En cas de doute entre les deux derniĂšres : ZeroDivisionError seulement pour un dĂ©nominateur nul; ValueError pour toutes les autres contraintes (nĂ©gatif, hors intervalle, etc.). Une condition comme volume <= 0 regroupe les deux cas : ValueError convient alors trĂšs bien.
Une fonction qui peut lever des exceptions doit les annoncer dans son docstring, dans une section Exceptions :.
Celui qui utilise la fonction sait alors exactement quelles valeurs sont refusées, sans lire tout le code.
def vitesse_moyenne(distance, temps):
"""
Calcule la vitesse moyenne d'un déplacement.
ParamĂštres :
distance (float) : Distance parcourue en mĂštres (m)
temps (float) : Durée du déplacement en secondes (s)
Retourne :
float : Vitesse moyenne en mĂštres par seconde (m/s)
Exceptions :
ValueError : si la distance ou le temps est négatif
ZeroDivisionError : si le temps est nul
"""
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
đ C'est le format attendu dans le TP1 : rĂŽle, paramĂštres, valeur de retour et exceptions.
Avant d'écrire le calcul, votre fonction a-t-elle :
- â placĂ© les validations au dĂ©but de la fonction, avant tout calcul?
- â
vérifié les types en premier (
int,float, etc.), puis les valeurs? - â vĂ©rifiĂ© les domaines (positif, non nul, dans un intervalle, etc.)?
- â couvert les cas limites (valeur nulle, nĂ©gative, bornes de l'intervalle, etc.)?
- â
donné un message utile à chaque
raise, qui correspond exactement Ă la condition testĂ©e? - â
annoncé chaque exception dans la section
Exceptions :du docstring?
Les explications de cette section étaient-elles claires ?
Nous avons déjà vu l'opérateur d'affectation = qui permet d'affecter une valeur à une variable :
x = 5
TrĂšs souvent, on veut modifier une variable Ă partir de sa propre valeur (ajouter 1, soustraire un montant, multiplier par un facteurâŠ).
Python propose des opérateurs d'affectation composés qui font l'opération et la réaffectation en une seule instruction.
Les trois que vous utiliserez le plus souvent, notamment dans les boucles :
| OpĂ©rateur | Exemple | Ăquivalent Ă |
|---|---|---|
| += | a += b | a = a + b |
| -= | a -= b | a = a - b |
| *= | a *= b | a = a * b |
Les autres opérateurs composés, pour référence :
| OpĂ©rateur | Exemple | Ăquivalent Ă |
|---|---|---|
| /= | a /= b | a = a / b |
| //= | a //= b | a = a // b |
| %= | a %= b | a = a % b |
| **= | a **= b | a = a ** b |
compteur = 0
compteur += 1 # Compter : on ajoute 1 Ă chaque fois
somme = 0
somme += 25 # Accumuler : on ajoute une valeur au total
temperature = 90
temperature *= 0.8 # Faire évoluer une valeur : elle baisse de 20 %
Ce sont exactement les opérations qu'on retrouvera dans les boucles de l'onglet while : on les répétera à chaque tour.
1. La variable doit exister avant d'ĂȘtre modifiĂ©e
total += 5 # â NameError: name 'total' is not defined
total += 5 veut dire total = total + 5 : Python a besoin de l'ancienne valeur de total.
Il faut donc toujours initialiser la variable avant (total = 0).
2. Inverser les symboles : =+ au lieu de +=
x = 5
x =+ 1 # â ïž Aucune erreur⊠mais x vaut maintenant 1!
print(x) # 1
x =+ 1 est lu comme x = +1 : on affecte simplement la valeur +1 Ă x.
Python n'affiche aucune erreur, ce qui rend ce bogue difficile à repérer. Le symbole de l'opération vient toujours avant le =.
Les explications de cette section étaient-elles claires ?
while, c'est un if qui se répÚteVous connaissez déjà le if : il vérifie une condition une seule fois et exécute son bloc si elle est vraie.
Le while fait exactement la mĂȘme chose⊠mais recommence tant que la condition est vraie.
On l'utilise quand on veut rĂ©pĂ©ter une action sans savoir d'avance combien de fois : c'est la condition elle-mĂȘme qui dĂ©cide quand s'arrĂȘter.
if : vérifié une seule fois
nombre = 3
if nombre < 100:
nombre *= 2
print(nombre) # 6
while : vérifié à chaque tour
nombre = 3
while nombre < 100:
nombre *= 2
print(nombre) # 192
Combien de fois faut-il doubler 3 pour dépasser 100? On ne le sait pas d'avance (ici, 6 fois), et ça changerait si on partait d'un autre nombre.
Avec un while, pas besoin de le savoir : on double tant que nombre < 100.
whileEn pseudo-code, la structure est la suivante :
Tant que (une certaine condition est vraie) :
# instructions à répéter
# instructions à répéter
# instructions à répéter
On répÚte les 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 Ă la ligne 5.
En Python, on utilise le mot-clé while :
compteur = 0
while compteur < 5:
print(f"Compteur = {compteur}")
compteur += 1 # Incrémente le compteur de 1
print("Fin de la boucle")
à chaque itération (tour de la boucle), on affiche le compteur (ligne 3) et on l'incrémente de 1 (ligne 4).
Quand compteur atteint 5, la condition compteur < 5 devient fausse (False) et la boucle se termine.
đ La condition est vĂ©rifiĂ©e avant chaque tour, y compris le premier. Si elle est fausse dĂšs le dĂ©part (par exemple avec compteur = 10), le bloc n'est jamais exĂ©cutĂ©, exactement comme un if dont la condition est fausse.
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 l'Ă©volution de compteur.
Ici, on connaĂźt d'avance le nombre de tours (5) : c'est un bon exemple pour apprendre la syntaxe.
Ă la rencontre 5, vous verrez que la boucle for est plus pratique dans ce cas. Le while, lui, est fait pour les situations oĂč on ne sait pas d'avance quand s'arrĂȘter.
whileToute boucle while a besoin de trois éléments :
- une initialisation avant la boucle :
compteur = 0; - une condition :
compteur < 5; - une mise à jour dans la boucle, qui fait évoluer la condition :
compteur += 1.
â ïž Si on oublie la mise Ă jour, la condition reste toujours vraie et la boucle ne s'arrĂȘte jamais : c'est une boucle infinie.
Quand une boucle ne se termine pas, vérifiez ces trois ingrédients!
đ Si votre programme ne s'arrĂȘte plus, cliquez sur le carrĂ© rouge âč (Stop) dans PyCharm (ou appuyez sur Ctrl + F2).
Cette boucle calcule 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(f"La somme des nombres de 1 Ă 10 est : {somme}")
à chaque itération, on ajoute nombre à somme, puis on passe au nombre suivant.
Quand nombre devient 11, la condition nombre <= 10 devient fausse et la boucle se termine.
Exécutez-le en mode débogage pour suivre l'évolution de somme et de nombre à chaque itération!
Dans l'exemple ci-dessus, somme est une variable accumulatrice : elle ne reçoit pas sa valeur finale d'un coup, elle s'enrichit à chaque tour de la boucle.
On la reconnaĂźt facilement :
- elle est initialisĂ©e avant la boucle (souvent Ă
0); - elle est mise Ă jour dans la boucle, souvent avec
+=; - on utilise sa valeur aprĂšs la boucle.
Un compteur (compteur += 1) est un cas particulier de variable accumulatrice : il compte le nombre de tours plutĂŽt que d'additionner des valeurs.
while et ifOn peut placer une structure conditionnelle à l'intérieur d'une boucle.
La condition est alors évaluée à chaque tour de la boucle : selon la valeur des variables à ce moment-là , le bloc if est exécuté ou non.
Voici un exemple qui affiche les nombres pairs de 0 Ă 10 :
i = 0
while i <= 10:
if i % 2 == 0: # Condition testée à chaque tour
print(i)
i += 1 # Hors du if : exécuté à chaque tour
- La boucle
whilefait varieride 0 Ă 10. - Ă chaque tour, le
ifvĂ©rifie siiest pair (reste de la division par 2 Ă©gal Ă 0). Si oui,iest affichĂ©. - â ïž L'instruction
i += 1est indentée au niveau duwhile, pas duif: elle doit s'exécuter à chaque tour, sinon la boucle ne se terminerait jamais (dÚs queivaut 1).
Le café sort de la machine à 90 °C et sa température baisse de 20 % chaque minute.
Combien de minutes faut-il attendre avant qu'il soit buvable (40 °C ou moins)? On ne le sait pas d'avance : c'est la condition qui dĂ©cide quand s'arrĂȘter.
temperature = 90
minutes = 0
while temperature > 40:
if temperature > 60:
print(f"Minute {minutes} : {temperature:.1f} °C, trop chaud!")
else:
print(f"Minute {minutes} : {temperature:.1f} °C, chaud")
temperature *= 0.8 # La température baisse de 20 %
minutes += 1
print(f"AprÚs {minutes} minutes, le café est buvable ({temperature:.1f} °C).")
Affichage :
Minute 0 : 90.0 °C, trop chaud!
Minute 1 : 72.0 °C, trop chaud!
Minute 2 : 57.6 °C, chaud
Minute 3 : 46.1 °C, chaud
AprÚs 4 minutes, le café est buvable (36.9 °C).
- Le
if/elsechoisit le message selon la température courante, à chaque tour. minutesest un compteur : il nous donne la réponse à la question une fois la boucle terminée.- Essayez avec une température de départ de 100 °C ou de 50 °C : le nombre de tours change, sans modifier la boucle!
Les explications de cette section étaient-elles claires ?