Conditions et logique booléenne en Python

Une comparaison pose une question sur des valeurs. Son résultat est une valeur booléenne : True ou False. Ce sont des valeurs de type bool, écrites avec une majuscule initiale et sans guillemets. "True" est du texte ; true en minuscules est un nom qui provoque une NameError lorsqu’il n’a pas été défini.

Choisir l’opérateur qui correspond à la règle

Les deux caractères d’un opérateur restent ensemble, avec = en dernier. Écris <=, et non =<. Un entier et un flottant peuvent être égaux : 7 == 7.0 donne True car leurs valeurs numériques sont égales.

Une comparaison est une expression : tu peux donc afficher ou stocker son résultat :

x = 7
is_big = x > 5
print(is_big)

Python évalue x > 5, obtient True et affecte cette valeur à is_big. La sortie est True. Un nom comme is_big ou has_ticket donne à une variable booléenne la forme d’une question à laquelle on répond par oui ou par non.

Distinguer affectation et comparaison

x = 5 stocke une nouvelle valeur dans x. x == 5 vérifie la valeur actuelle sans la modifier. Écrire if x = 5: est une erreur de syntaxe. L’erreur inverse peut être plus difficile à remarquer :

x = 7
x == 5
print(x)

Dans un script, le résultat de la comparaison n’est pas utilisé. La sortie reste 7 ; la ligne du milieu n’affecte jamais 5.

Effectuer les calculs avant de comparer

Dans 2 + 3 > 4, Python effectue d’abord l’addition et obtient 5, puis compare 5 > 4. Le résultat est True. Un test utile pour les entiers est n % 2 == 0 : % donne le reste de la division et les nombres pairs donnent un reste de 0 lorsqu’ils sont divisés par 2.

Pour n = 10, les étapes sont 10 % 2, puis 0 == 0, ce qui donne True. Pour n = -7, -7 % 2 vaut 1 : le test de parité vaut donc False. Avec le diviseur positif 2, le reste donné par Python pour un entier impair est 1, même si cet entier impair est négatif.

Déterminer si la limite est incluse

« Au moins 18 » inclut 18 : age >= 18. « Plus de 18 » l’exclut : age > 18. De même, « moins de 13 » s’écrit age < 13 et « au maximum 3 » s’écrit bags <= 3. Teste la valeur limite elle-même lorsque tu choisis un opérateur. Pour age = 18, le premier test sur l’âge est vrai et le second est faux.

Tenir compte des minuscules écarts entre flottants

De nombreuses fractions décimales n’ont qu’une représentation binaire approchée. Python stocke 0.1 + 0.2 sous la forme 0.30000000000000004 : 0.1 + 0.2 == 0.3 vaut donc False.

Pour une comparaison avec une tolérance absolue de 1e-9, utilise :

print(abs((0.1 + 0.2) - 0.3) < 1e-9)

abs() donne la valeur absolue de la différence. Cette différence est inférieure à un milliardième : le test affiche donc True. La tolérance indique l’écart accepté par cette vérification ; il ne s’agit pas d’une égalité exacte.

Les valeurs de part et d’autre d’une comparaison comptent autant que l’opérateur. Un texte peut ressembler à un nombre tout en suivant les règles des chaînes.

Comparer le texte exactement

L’égalité de chaînes vérifie chaque caractère, y compris la casse et les espaces. "yes" == "Yes" vaut False, et "yes" == "yes " vaut aussi False. Pour accepter les différences courantes de majuscules et les espaces autour du texte, compare une copie nettoyée :

answer = " Yes "
print(answer.strip().lower() == "yes")

strip() supprime les caractères d’espacement aux deux extrémités. lower() met les lettres en minuscules. Le texte nettoyé est "yes" : le résultat vaut donc True. La valeur stockée dans answer reste inchangée, sauf si tu lui affectes la valeur nettoyée.

Comprendre l’ordre des chaînes

Python compare les chaînes de gauche à droite à l’aide des points de code Unicode, les nombres attribués aux caractères. Il s’arrête à la première paire inégale. Avec des lettres anglaises non accentuées de même casse, cela suit l’ordre alphabétique : "apple" < "banana" vaut True. Lorsqu’une chaîne forme le début de l’autre, la plus courte vient en premier : "cat" < "catalog" vaut True.

Ce n’est pas une règle complète de classement de dictionnaire. Les lettres de A à Z ont les points de code 65 à 90 et celles de a à z ont les points de code 97 à 122. Ainsi, "Zebra" < "apple" vaut True. Le é accentué vient aussi après z, donc "zebra" < "éclair" vaut True.

Les chiffres dans les chaînes suivent la même règle de comparaison des caractères. "10" < "9" vaut True : la première comparaison porte sur "1" et "9", et non sur les nombres dix et neuf.

Convertir les saisies pour prendre des décisions numériques

input() renvoie une chaîne. Si quelqu’un saisit 5, "5" == 5 donne False : le test d’égalité ne convertit pas le texte. Une comparaison d’ordre se comporte autrement : "5" < 10 provoque une TypeError car Python ne peut pas comparer l’ordre de cette chaîne et de cet entier.

age = int(input("Age: "))
print(age >= 18)

Pour le texte saisi "18", int() produit l’entier 18 et le test affiche True. Utilise float() lorsque la saisie représente une valeur décimale.

Utiliser une chaîne de comparaisons pour un intervalle

0 <= score <= 100 exige que les deux comparaisons entre valeurs voisines soient vraies. Cela signifie 0 <= score and score <= 100. Pour score = 105, le test de la borne inférieure réussit, mais celui de la borne supérieure échoue : toute la chaîne vaut donc False.

Une chaîne ne compare que les valeurs voisines. 1 < 3 > 2 vaut True car 1 < 3 et 3 > 2 sont tous deux vrais ; elle ne compare pas directement 1 à 2.

Choisir l’appartenance ou l’identité au besoin

Les opérateurs d’appartenance vérifient si un texte apparaît dans un autre. "nan" in "banana" vaut True ; "Ban" in "banana" vaut False. "x" not in "banana" vaut True.

None représente une absence de valeur. Vérifie-la avec result is None ou result is not None. L’opérateur is demande s’il s’agit exactement du même objet, tandis que == demande si les valeurs sont égales. Utilise == pour vérifier l’égalité de nombres et de chaînes : un test d’identité comme x is 5 n’est pas fiable à cette fin et produit un SyntaxWarning.

Une instruction if n’exécute un bloc que lorsque sa condition est vraie. L’en-tête commence par if, indique la condition et se termine par deux-points. Les lignes situées en dessous sont indentées pour montrer qu’elles appartiennent à son corps.

Suivre une décision à une branche

temperature = 31
if temperature > 30:
    print("Hot day")
    print("Drink water")
print("Done")

À l’en-tête, Python lit la valeur actuelle de temperature. La comparaison 31 > 30 vaut True, donc les deux lignes indentées s’exécutent. Le programme atteint ensuite la ligne située hors du bloc. Sa sortie est :

Hot day
Drink water
Done

Remplace la première ligne par temperature = 25. Maintenant, 25 > 30 vaut False : Python ignore donc tout le corps. Seul Done s’affiche. La condition est testée une fois lorsque Python atteint l’en-tête ; un if ne la vérifie pas en continu.

Montrer l’appartenance par l’indentation

Par convention, utilise 4 espaces pour chaque niveau d’indentation. Les lignes au même niveau appartiennent au même bloc. Le retour au niveau extérieur met fin au bloc. Si tu indentes print("Done") de 4 espaces, cette instruction entre dans le corps du if et ne s’affiche que lorsque la condition est satisfaite.

Un algorigramme représente le même choix par un losange. Le chemin « vrai » entre dans le corps, le chemin « faux » le contourne et les chemins se rejoignent à l’instruction suivante, hors du bloc.

Python peut signaler SyntaxError, IndentationError ou TabError pour ces problèmes. Commence par examiner l’en-tête et l’indentation autour de la ligne signalée. Les parenthèses autour de la condition sont facultatives ; if temperature > 30: est la forme habituelle.

Un corps ne peut pas être vide. Pour réserver la place d’une action, écris un pass indenté. C’est une instruction valide qui ne fait rien :

if temperature > 30:
    pass

Les vérifications séparées sont indépendantes

score = 95
if score >= 50:
    print("Pass")
if score >= 90:
    print("Excellent")

Python atteint les deux en-têtes. Les deux conditions sont vraies : il affiche donc les deux messages. Des instructions if séparées conviennent aux règles dont toutes les actions peuvent s’appliquer à une même entrée.

Donner au code ultérieur une valeur utilisable

Un nom auquel une valeur n’est affectée que dans le corps peut ne jamais être créé :

x = 0
if x > 0:
    message = "positive"
print(message)

Dans un nouveau script, le corps est ignoré et message n’a pas de valeur : la dernière ligne provoque donc une NameError. Une solution consiste à fournir une valeur initiale avant le choix :

x = 0
message = "not positive"
if x > 0:
    message = "positive"
print(message)

La ligne ultérieure dispose maintenant d’une valeur sur les deux chemins. Pour zéro, elle affiche not positive ; pour un x positif, le corps remplace ce texte par positive.

Une instruction if–else choisit l’un de deux blocs. Lorsque la condition est vraie, Python exécute le corps du if. Sinon, il exécute le corps du else. Exactement l’un des deux s’exécute lorsque l’exécution atteint cette décision.

Aligner les alternatives

number = int(input("Enter a whole number: "))
if number % 2 == 0:
    print(number, "is even")
else:
    print(number, "is odd")

Pour la saisie 14, le reste est 0 : la sortie est donc 14 is even. Pour la saisie -7, le reste est 1 : la sortie est donc -7 is odd. Le else appartient au if situé au même niveau d’indentation. Son corps possède sa propre indentation.

Il n’y a pas de condition après else : cela signifie que la condition précédente était fausse. else number < 0: est une erreur de syntaxe. Place la clause directement après le corps du if ; une instruction non indentée et sans rapport entre les deux rompt la structure.

Vérifier ce que comprend « tout le reste »

Avec if answer == "yes":, un else ne signifie pas seulement "no". Il accepte aussi "maybe", "Yes" et "", car aucune de ces valeurs n’est égale à "yes". C’est utile lorsque toutes les autres entrées appellent la même action. Si plusieurs entrées rejetées appellent des réponses différentes, il faut d’autres tests.

Affecter une valeur sur les deux chemins

Une règle prévoit la livraison gratuite pour les totaux d’au moins 50 € et facture 5,99 € dans les autres cas :

total = 42.50
if total >= 50:
    shipping = 0
else:
    shipping = 5.99
print(total + shipping)

D’abord, 42.50 >= 50 donne False. Python ignore l’affectation de 0, exécute le else et stocke 5.99. La dernière ligne est hors des deux corps et affiche 48.49. Remplace total par 60 : le premier corps stocke 0, l’autre est ignoré et la dernière ligne affiche 60. Les deux chemins définissent shipping avant son utilisation.

Choisir une valeur avec une expression conditionnelle

Lorsque la seule différence est la valeur à affecter, une expression conditionnelle peut l’exprimer en une ligne :

shipping = 0 if total >= 50 else 5.99

Sa forme est value_if_true if condition else value_if_false. Bien que la valeur correspondant au cas vrai apparaisse en premier sur la page, Python évalue d’abord la condition. Il évalue uniquement la valeur choisie, puis affecte le résultat à shipping.

Un autre exemple est label = "even" if n % 2 == 0 else "odd". Pour n = 14, il sélectionne "even". Pour n = -7, il sélectionne "odd".

L’expression nécessite les deux valeurs. x = 1 if flag est incomplet et provoque une SyntaxError car il n’y a pas de valeur après else. Une instruction if complète peut omettre else car elle peut simplement ne rien faire sur le chemin où la condition est fausse ; une expression doit tout de même produire une valeur.

Utilise elif, abréviation de « else if », pour ajouter un test à une décision. Python essaie les conditions de haut en bas. La première condition vraie l’emporte et le reste de la chaîne est ignoré.

Suivre une décision sur une note

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(grade)

Le premier test, 85 >= 90, est faux. Le deuxième, 85 >= 80, est vrai : Python stocke donc "B". Il ne teste pas les conditions restantes et n’entre pas dans else. La sortie est B.

Utiliser les résultats des échecs précédents

Atteindre elif score >= 80: t’indique déjà que le score est inférieur à 90. Pour des scores entiers, cette branche couvre les valeurs de 80 à 89. Ajouter and score < 90 répéterait une vérification que le programme a déjà effectuée.

L’ordre compte car ces intervalles se chevauchent. Si score >= 60 vient en premier, il retient 85 et 95 avant que les tests des notes supérieures ne soient atteints. Pour des tests de borne inférieure avec >=, place le seuil le plus élevé en premier. Pour des tests de borne supérieure avec <, commence par le seuil le plus bas.

Garder un choix dans une seule chaîne

Remplacer les mots-clés elif par if change le comportement. Avec un score de 85, le test de 80 affecte "B", celui de 70 affecte ensuite "C" et celui de 60 affecte "D". La valeur finale est "D". Chaque nouveau if commence une décision indépendante.

Cette distinction concerne aussi else. Dans un groupe d’instructions if séparées, un else final appartient uniquement au if qui lui correspond, et non au groupe entier. Garde les branches liées lorsqu’elles représentent une seule classification.

Prévoir les limites et les entrées sans correspondance

Une chaîne elif peut comporter autant de tests supplémentaires que nécessaire et son else final est facultatif. Sans branche par défaut, elle peut n’exécuter aucun corps :

temp = 20
if temp < 18:
    print("Cool")
elif temp > 24:
    print("Warm")

Aucune des deux conditions n’est satisfaite. Ajoute else: avec un print("Comfortable") indenté si chaque température doit produire un message. De même, t < 18 suivi de t > 18 laisse exactement 18 sans correspondance. Aux seuils des notes, écrire score > 90 enverrait 90 dans la branche "B".

Les menus textuels utilisent la même structure : teste choice == "1", puis choice == "2", et donne une réponse "Unknown option" à toute autre saisie. Ces vérifications comparent des chaînes car input() renvoie du texte. Lorsque de nombreux tests comparent une valeur à des choix fixés, match offre une autre façon de structurer la décision.

Les opérateurs booléens and, or et not permettent de construire une condition à partir de conditions plus simples. Python les écrit sous forme de mots en minuscules.

Lire toutes les possibilités

Pour des entrées booléennes, and donne True uniquement lorsque les deux entrées sont vraies. or donne True lorsqu’au moins l’une est vraie, y compris lorsque les deux sont vraies. C’est un ou inclusif.

not inverse une valeur de vérité : not True donne False et not False donne True. Une table de vérité présente toutes les combinaisons d’entrées booléennes. Deux entrées nécessitent quatre lignes ; trois en nécessitent huit. Chaque entrée booléenne indépendante supplémentaire double le nombre de combinaisons.

Pour A and not B, inverse d’abord B, puis combine le résultat avec A. Dans la ligne A = True, B = False, not B vaut True, donc le résultat vaut True. Les trois autres lignes donnent False.

Traduire une règle en tests complets

Un musée accorde une réduction sur l’entrée aux visiteurs de moins de 12 ans ou âgés de 65 ans et plus :

has_discount = age < 12 or age >= 65

À 10 ans, la première comparaison réussit. À 65 ans, la seconde réussit. Les âges 30 et 64 ne satisfont aucune des deux. Utiliser and exigerait qu’un même âge soit inférieur à 12 et au moins égal à 65, ce qui est impossible.

Une attraction exige une taille d’au moins 120 centimètres et l’absence de problème cardiaque :

can_ride = height >= 120 and not has_heart_condition

Les deux exigences doivent être satisfaites ensemble. À la taille minimale avec has_heart_condition = False, les deux parties sont satisfaites. Si l’une des exigences échoue, can_ride vaut False.

Distinguer l’intérieur de l’extérieur d’un intervalle

Le test de l’intérieur nécessite les deux bornes. Le test de l’extérieur nécessite que l’une ou l’autre soit dépassée. score < 0 and score > 100 ne peut jamais être vrai pour un même nombre.

Chaque comparaison doit avoir deux côtés. score >= 0 and <= 100 est une syntaxe incomplète. Un problème plus subtil s’exécute sans erreur :

if answer == "y" or "yes":
    print("Accepted")

Python voit (answer == "y") or "yes". Lorsque la comparaison est fausse, la chaîne non vide "yes" suffit à donner une valeur vraie à la condition. Répète la comparaison : answer == "y" or answer == "yes".

Les formulations courantes demandent autant d’attention. « Fermé le samedi et le dimanche » signifie day == "Saturday" or day == "Sunday" ; un même jour n’a pas besoin de porter les deux noms à la fois. Pour une variable booléenne, utilise directement la négation not is_member. Une comparaison niée comme not (age >= 18) peut aussi s’écrire plus simplement age < 18. Les opérateurs Python employés ici sont des mots, et non &&, || ou !.

Une condition plus longue soulève deux questions : comment ses parties sont regroupées et lesquelles Python évalue effectivement. La priorité des opérateurs répond à la première. L’évaluation en court-circuit répond à la seconde.

Lire d’abord le regroupement

Pour les opérateurs utilisés ici, voici l’ordre de priorité, de la plus forte à la plus faible :

1. Élévation à la puissance : **.
2. Multiplication, division, division entière, reste : *, /, //, %.
3. Addition et soustraction : +, -.
4. Comparaisons, notamment in, not in, is et is not.
5. not, puis and, puis or.
6. L’expression conditionnelle : a if condition else b.

Les parenthèses modifient le regroupement. Par exemple, x > 3 or x < 0 and x != 5 se regroupe ainsi : x > 3 or (x < 0 and x != 5). Pour x = 5, la comparaison de gauche est vraie et tout le groupe de droite est ignoré. Le résultat est True.

Avec (x > 3 or x < 0) and x != 5, les parenthèses font du premier groupe un opérande de and. Pour x = 5, ce groupe est vrai, mais x != 5 est faux : le résultat est donc False.

C’est pourquoi is_weekend or is_holiday and is_sunny accepte tous les week-ends, même sous la pluie. Pour la règle « un jour de repos où il fait aussi beau », écris (is_weekend or is_holiday) and is_sunny.

Suivre l’évaluation de gauche à droite

Pour and, une première partie fausse a déjà rendu l’ensemble de la condition impossible à satisfaire. Pour or, une première partie vraie l’a déjà satisfaite. La priorité n’oblige pas Python à calculer un opérande ignoré simplement parce qu’il contient des opérateurs plus prioritaires.

Tu peux t’en servir pour placer une condition de garde avant une opération qui échouerait :

count = 0
total = 50
is_large_average = count != 0 and total / count > 10
print(is_large_average)

count != 0 est faux : Python ne tente donc jamais 50 / 0. Il stocke et affiche False. Inverser les opérandes tente d’abord la division et provoque une ZeroDivisionError ; la vérification ultérieure ne peut pas protéger une opération précédente.

Faire passer not à travers un test regroupé

Les lois de De Morgan réécrivent une négation en inversant chaque partie et en changeant l’opérateur qui les relie :

« Ne pas être adolescent » peut être testé avec not (age >= 13 and age <= 19). Le test direct équivalent est age < 13 or age > 19. Les âges 12 et 20 satisfont le test ; 13, 16 et 19 ne le satisfont pas.

Conserver and après avoir nié les deux parties change la règle. Pour A = True, B = False, not (A and B) est vrai, mais not A and not B est faux. Compare chaque ligne des tables de vérité pour vérifier l’équivalence de deux formes booléennes.

Pour une variable qui contient déjà un booléen, écris if is_valid: ou if not is_valid:. La comparer à True ou False ajoute un test dont la condition n’a pas besoin.

Une instruction conditionnelle imbriquée place une décision dans une branche d’une autre décision. La décision interne n’est atteinte que lorsque l’exécution entre dans cette branche externe. Chaque niveau d’imbrication ajoute 4 espaces d’indentation.

Suivre le choix externe avant le choix interne

has_ticket = True
age = 15
if has_ticket:
    if age >= 13:
        print("Enjoy the movie")
    else:
        print("This movie needs an adult")
else:
    print("Please buy a ticket first")

D’abord, has_ticket est vrai : Python entre donc dans le corps externe. Il teste ensuite 15 >= 13, obtient vrai et affiche Enjoy the movie. Les corps des else interne et externe sont tous deux ignorés.

Remplace l’âge par 10 tout en gardant le billet. Python entre toujours dans le corps externe, mais la condition interne échoue : il affiche donc This movie needs an adult. Avec has_ticket = False, le test de l’âge n’est jamais atteint ; le else externe affiche Please buy a ticket first.

Associer chaque else grâce à l’indentation

Un else appartient au if situé à son propre niveau d’indentation. Le déplacer peut changer le comportement même si le script reste valide. Considère cette variante plus courte :

if has_ticket:
    if age >= 13:
        print("Enter")
else:
    print("Buy a ticket")

Le else appartient à if has_ticket:. Un enfant de 10 ans avec un billet ne reçoit aucun message. Déplace ce else et son corps d’un niveau vers l’intérieur : il appartient alors à if age >= 13:. Le même enfant reçoit maintenant Buy a ticket, tandis qu’une personne sans billet ne reçoit aucun message. La nouvelle disposition exprime une règle différente.

Dans l’exemple complet du film, le if interne possède déjà un else. Déplacer le else externe vers l’intérieur créerait deux alternatives pour le même if et provoquerait une erreur de syntaxe.

Aplatir deux exigences

Lorsqu’il n’y a qu’une seule action et qu’aucun des deux niveaux n’a de else, and supprime souvent un niveau d’imbrication :

if is_member and total >= 50:
    print("Free shipping")

Cela exécute la même action qu’un if is_member: externe contenant un if total >= 50: interne. Les deux exigences doivent être satisfaites et la seconde n’est atteinte qu’après la réussite de la première. Garde l’imbrication lorsque les branches externes nécessitent leurs propres actions distinctes, comme pour l’achat d’un billet.

Un else dont la seule action est un autre if–else peut devenir une chaîne elif. Pour les cas positif, négatif et zéro, la forme aplatie est if x > 0:, puis elif x < 0:, puis else:. Elle conserve les mêmes trois résultats avec moins d’indentation.

Valider avant de classer

Une décision sur une note doit rejeter les scores hors de l’intervalle autorisé avant d’attribuer une lettre :

if 0 <= score <= 100:
    if score >= 90:
        print("A")
    else:
        print("Below A")
else:
    print("Score must be between 0 and 100")

Pour score = 150, la vérification externe échoue : aucune note n’est donc attribuée. L’imbrication révèle aussi les chemins impossibles : un if x < 5: interne sous if x > 10: ne peut jamais réussir. Lorsque l’indentation devient profonde, cherche des exigences à combiner, une chaîne elif ou une vérification préalable qui rend les chemins restants plus clairs.

Python peut tester directement une valeur dans une condition. Sa valeur de vérité détermine si le corps s’exécute. Cela évite des comparaisons, mais la valeur de vérité peut différer de ce que son texte semble dire.

Reconnaître les valeurs fausses

Pour les types natifs présentés ici, False, None, zéro numérique, les chaînes vides et les collections vides sont des valeurs fausses. Les nombres non nuls et les chaînes ou collections non vides sont des valeurs vraies.

bool() convertit une valeur en sa valeur de vérité booléenne. Dans une condition, if value: choisit la même branche que if bool(value):. Cette instruction ne transforme pas la valeur stockée en booléen.

Tester une saisie vide sans se tromper

name = input("Name: ")
if name:
    print("Hello", name)
else:
    print("No name entered")

Appuyer sur Entrée sans rien saisir donne "" : le second corps s’exécute donc. Un nom composé uniquement d’espaces n’est pas vide et satisfait le premier test. if name.strip(): teste plutôt le texte après suppression des caractères d’espacement autour de lui : une réponse composée uniquement d’espaces échoue donc aussi.

Une réponse par oui ou par non appelle une autre question. if answer: s’exécute pour "no" et "False" car les deux contiennent des caractères. Pour reconnaître une réponse affirmative, compare le texte, par exemple avec answer == "yes". La valeur de vérité vérifie si la chaîne est vide, et non le sens d’un mot.

Distinguer un zéro valide de données manquantes

Supposons que quantity vaille None avant qu’une valeur soit fournie et puisse valablement être 0. if quantity: rejette les deux. Utilise quantity is not None pour demander si une valeur est présente ; ce test accepte zéro.

Pour une véritable variable booléenne, un test direct est clair. Pour les autres valeurs, x == True fait autre chose que if x:. Avec x = 5, le test de valeur de vérité réussit, mais 5 == True est faux ; l’égalité numérique considère que True est égal à 1, et non à tout nombre non nul.

and et or renvoient une valeur examinée

Ces opérateurs renvoient un opérande, qui peut ne pas être un booléen :

Pour or, Python renvoie la valeur de gauche si elle est vraie ; sinon, il évalue et renvoie la valeur de droite. Pour and, il renvoie la valeur de gauche si elle est fausse ; sinon, il évalue et renvoie la valeur de droite.

display_name = name or "Guest" fournit une valeur par défaut pour une saisie vide. Le même schéma avec quantity or 1 remplace un zéro réel par 1. Utilise une valeur par défaut de cette façon uniquement lorsque toute valeur fausse signifie qu’une valeur manque. not se comporte autrement : il renvoie toujours True ou False. Si un drapeau stocké doit être booléen, has_name = bool(name or nickname) convertit le texte sélectionné en valeur de vérité.

Un script peut s’exécuter sans erreur de syntaxe tout en choisissant la mauvaise branche. Le traçage consiste à suivre une exécution à la main. Les tests consistent à exécuter le programme avec des entrées choisies et à comparer le résultat observé à celui qu’exige la règle.

Préparer et suivre un chemin

Avant d’écrire du code, énonce les choix sous forme d’étapes en langage courant, ou pseudo-code. Un algorigramme place chaque condition dans un losange avec des flèches « vrai » et « faux ». Les deux chemins doivent mener clairement à une étape suivante ou à une fin.

Pour suivre le code, note les valeurs initiales, évalue chaque condition atteinte, consigne les affectations et copie exactement la sortie. Pour la chaîne des notes avec score = 72 :

« Non évalué » ne signifie pas faux. Python a déjà sélectionné une branche : il n’a donc pas besoin des comparaisons suivantes.

Couvrir chaque branche et chaque limite

Une chaîne à quatre branches nécessite au moins quatre entrées pour exécuter chaque branche une fois. Choisis-les selon les chemins prévus, et non selon la variété apparente des nombres. Plusieurs scores élevés peuvent tous exercer le même premier corps.

La couverture des branches peut à elle seule laisser passer une limite incorrecte. Pour age >= 18, teste 17, 18 et 19. Un > erroné réussit les deux tests de part et d’autre comme prévu, mais rejette la valeur limite elle-même. Pour un seuil de note de 90, compare 89, 90 et 91 ; fais de même pour les autres seuils. Pour des entrées décimales, choisis des valeurs proches adaptées à la précision de la mesure.

Trouver les branches qui ne peuvent pas s’exécuter

if score >= 60:
    print("Pass")
elif score >= 90:
    print("Excellent")

La seconde branche est inaccessible. Tout score d’au moins 90 a déjà satisfait le premier test. Place le seuil le plus restrictif en premier ou modifie les intervalles pour qu’ils correspondent à la règle voulue.

Un cas non couvert laisse un cas prévu sans traitement : t < 0 suivi de t > 0 ignore zéro. Un chevauchement peut faire exécuter plusieurs actions indépendantes : les tests séparés t >= 0 et t <= 10 réussissent tous deux pour 5. Une chaîne ne permet d’exécuter que sa première branche vraie, mais son ordre détermine toujours quelle condition l’emporte en cas de chevauchement.

Inclure les entrées difficiles

Teste les valeurs négatives, zéro, le texte vide et les réponses en majuscules lorsque le script attend des minuscules. Si seuls "y" et "n" sont acceptés, donne à tout autre texte une réponse claire comme "Please answer y or n".

Lorsqu’un test se comporte de façon inattendue, examine la valeur et son type avant d’évaluer la comparaison suspecte :

print(repr(age), type(age))

Pour age = "18", cela affiche '18' <class 'str'>. Convertis le texte avant d’essayer age >= 18 ; placer la comparaison incorrecte dans ce même print() de débogage provoquerait une TypeError avant l’affichage du diagnostic. Pour les problèmes de structure, examine l’indentation et le message d’erreur de syntaxe.

Enfin, une comparaison peut définir directement un drapeau booléen : is_adult = age >= 18. Elle remplace deux branches dont les seules affectations sont True et False. Utilise bool() lorsque l’expression sous-jacente peut renvoyer un autre type de valeur.

Une instruction match, disponible dans Python 3.10 et les versions ultérieures, compare une valeur à une série de motifs. Cette valeur est le sujet. Chaque case fournit un motif et un corps indenté.

Suivre le premier cas correspondant

command = "stop"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")
print("Ready")

Le sujet est "stop". Il ne correspond pas à "start", donc Python essaie le cas suivant. "stop" correspond et le corps affiche Stopping. Python quitte ensuite toute l’instruction match et affiche Ready. Un seul corps de cas s’exécute ; l’exécution ne se poursuit pas dans le corps suivant et aucun break n’est nécessaire.

Un sujet égal à "jump" atteint le motif attrape-tout final, _, qui accepte toute valeur. La sortie est Unknown command, puis Ready. Sans ce cas, un sujet sans correspondance n’exécute simplement aucun corps de cas et l’exécution continue après l’instruction.

Respecter la disposition et l’ordre du cas par défaut

Les en-têtes case sont indentés de 4 espaces sous match, et leurs corps de 4 espaces supplémentaires. Chaque en-tête se termine par deux-points. Un case _: sans garde doit être placé en dernier, car il accepte tout. Placer d’autres cas après lui provoque une SyntaxError : ces motifs ultérieurs ne pourraient jamais être atteints.

Un motif attrape-tout avec une garde peut apparaître plus tôt, car sa condition supplémentaire peut échouer. Une instruction match dans un script à exécution linéaire ne peut pas non plus contenir break ; cette instruction nécessite une boucle englobante.

Comprendre la correspondance des littéraux

Un motif littéral utilise un nombre fixé, une chaîne, True, False ou None. Les motifs de chaîne sont exacts et sensibles à la casse : "stop" ne correspond pas à "Stop". Les motifs numériques utilisent l’égalité : case 1: correspond donc à 1, 1.0 et True, qui est égal à 1.

Les motifs True, False et None utilisent quant à eux l’identité. Ainsi, case True: correspond au booléen True, mais pas à l’entier 1. L’ordre des motifs compte si un cas numérique et un cas booléen peuvent tous deux accepter le sujet.

Relier des alternatives fixées par une barre

Un motif OU relie des alternatives avec | :

day = int(input("Day number: "))
match day:
    case 6 | 7:
        print("Weekend")
    case 1 | 2 | 3 | 4 | 5:
        print("Weekday")
    case _:
        print("Not a day number")

Pour 6, le premier corps s’exécute ; pour 3, le deuxième s’exécute ; pour 9, le motif attrape-tout s’exécute. Sans int(), la saisie "6" reste une chaîne et ne correspond pas au nombre 6.

Utilise le séparateur de motifs |, et non le mot booléen or. case "y" or "yes": est invalide ; case "y" | "yes": est valide.

Pour des commandes fixées, une chaîne if–elif fondée sur l’égalité peut produire les mêmes sorties. Choisis la disposition qui rend les cas les plus faciles à lire.

Les motifs peuvent faire plus que vérifier un littéral fixé. Un motif peut donner un nom au sujet et une garde peut vérifier une condition supplémentaire avant que le cas soit accepté.

Capturer d’abord, puis vérifier la garde

Un motif de capture est un nom seul comme n. Il accepte tout sujet et l’affecte à ce nom. Une garde suit le motif sous la forme if condition ; le corps ne s’exécute que si le motif correspond et que la garde est vraie.

temperature = -5
match temperature:
    case 0:
        print("Exactly freezing")
    case t if t < 0:
        print("Below freezing by", -t, "degrees")
    case _:
        print("Above freezing")

Pour -5, le premier littéral ne correspond pas. Le motif suivant capture -5 dans t, puis teste t < 0. La garde est vraie : la sortie est donc Below freezing by 5 degrees.

Pour 0, le cas littéral l’emporte avant que la capture soit essayée. Pour 12, la capture réussit mais la garde échoue : Python essaie donc le motif attrape-tout et affiche Above freezing. L’échec d’une garde ne met pas fin à la recherche d’un cas.

Un nom seul ne recherche pas une constante

Supposons que QUIT = "q". Il est tentant d’écrire case QUIT: pour vérifier si le sujet est égal à cette valeur. Mais un nom seul est toujours une capture, même en majuscules. Le cas accepte tout sujet et remplace la valeur de QUIT par celui-ci.

Si d’autres cas suivent une capture sans garde, Python signale une erreur de syntaxe car la capture les rend inaccessibles. Si la capture est en dernier, l’erreur peut passer inaperçue à l’exécution. Effectue explicitement la comparaison avec une garde :

QUIT = "q"
key = "x"
match key:
    case k if k == QUIT:
        print("Quit")
    case _:
        print("Keep working")

Ici, k capture "x". La garde compare cette valeur au "q" existant, échoue et laisse le motif attrape-tout afficher Keep working. Un littéral case "q": est plus simple lorsque la valeur fixée peut être écrite directement.

Distinguer un motif valeur en notation pointée

Un nom en notation pointée comme math.pi est un motif valeur, et non une capture. Il recherche une valeur existante et lui compare le sujet avec ==. Les constantes nommées fournies par des modules ou des classes peuvent utiliser cette forme. Le point permet de faire la distinction : case n: affecte une valeur à un nom ; un motif en notation pointée vérifie une valeur existante.

Nommer une correspondance précise avec as

answer = "y"
match answer:
    case "y" | "yes" as accepted:
        print("Accepted:", accepted)
    case _:
        print("Please answer y or yes")

Le motif OU vérifie les chaînes autorisées et as stocke le sujet correspondant dans accepted. Pour "y", la sortie est Accepted: y. Il ne remplace pas la saisie par un mot standard : "yes" stockerait "yes". "Yes" ne correspond à aucune des deux chaînes, car la casse compte toujours.

Une ou deux gardes peuvent s’intégrer naturellement parmi des cas fixés. Lorsque presque chaque cas est un test d’intervalle ou utilise des variables différentes, une chaîne if–elif est généralement plus claire. Les deux structures nécessitent un cas par défaut final lorsque chaque entrée doit recevoir une réponse.