7. Booléens et conditions

Dans les chapitres précédents, vous avez appris à travailler avec les nombres, les chaînes de caractères et les opérations de base sur les données. Nous sommes maintenant prêts à explorer comment Python prend des décisions — une capacité fondamentale qui permet aux programmes de réagir différemment en fonction de conditions variables. Au cœur de la prise de décision en Python se trouvent les valeurs booléennes et les conditions.

Pensez aux décisions de tous les jours : « S'il pleut, je prends un parapluie. » « Si la température est supérieure à 30 °C, j'allume la climatisation. » Ces décisions sont basées sur des conditions qui sont soit vraies, soit fausses. Python utilise le même principe : il évalue des conditions pour déterminer si elles sont vraies ou fausses, puis agit en conséquence.

Dans ce chapitre, nous allons explorer les valeurs booléennes, apprendre à créer des conditions à l'aide des opérateurs de comparaison, comprendre la notion de « truthiness » de Python, et découvrir des techniques puissantes pour construire des expressions logiques complexes. À la fin de ce chapitre, vous aurez maîtrisé les briques de base nécessaires pour les instructions if et les boucles que vous apprendrez dans les chapitres suivants.

7.1) Les valeurs booléennes True et False

Python possède un type de données spécial appelé bool (abréviation de Boolean) qui représente des valeurs de vérité. Ce type n'a que deux valeurs possibles : True et False. Remarquez que ces valeurs commencent par une majuscule — c'est important en Python. Écrire true ou false (en minuscules) provoquera une erreur, car Python ne les reconnaît pas.

python

# boolean_basics.py
# Création de variables booléennes
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

Les valeurs booléennes sont fondamentales car elles représentent le résultat de toute question de type oui/non que votre programme pourrait poser : ce nombre est-il supérieur à 10 ? Cette chaîne contient-elle la lettre 'a' ? L'utilisateur est-il connecté ? Chaque condition en Python évalue finalement à True ou False.

7.1.1) Booléens dans les variables et les expressions

Vous pouvez stocker des valeurs booléennes dans des variables comme vous stockez des nombres ou des chaînes de caractères. C'est utile lorsque vous voulez suivre l'état de quelque chose dans votre programme :

python

# boolean_variables.py
# Utilisation de variables booléennes pour suivre des états
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Les variables booléennes peuvent être réaffectées
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Les variables booléennes sont souvent nommées avec des préfixes comme is_, has_ ou can_ pour rendre leur rôle clair. Cette convention de nommage aide vous-même et les autres personnes lisant votre code à comprendre immédiatement que la variable contient une valeur vrai/faux.

7.2) Opérateurs de comparaison et conditions de base

Même si vous pouvez créer des valeurs booléennes directement avec True et False, la plupart des valeurs booléennes dans vos programmes proviendront de comparaisons — des tests de relation entre des valeurs. Python fournit plusieurs opérateurs de comparaison qui comparent deux valeurs et produisent un résultat booléen.

7.2.1) Les six opérateurs de comparaison

Python possède six opérateurs de comparaison principaux :

Operator	Signification	Exemple	Résultat
`==`	Égal à	`5 == 5`	`True`
`!=`	Différent de	`5 != 3`	`True`
`<`	Strictement inférieur à	`3 < 5`	`True`
`>`	Strictement supérieur à	`5 > 3`	`True`
`<=`	Inférieur ou égal à	`5 <= 5`	`True`
`>=`	Supérieur ou égal à	`5 >= 3`	`True`

Voyons ces opérateurs en action :

python

# comparison_operators.py
# Comparaison de nombres
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Comparaisons avec des valeurs égales
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Comparer des nombres et des chaînes

Les opérateurs de comparaison fonctionnent avec de nombreux types de valeurs, pas seulement les entiers :

python

# comparing_types.py
# Comparaison de nombres flottants
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Comparaison de chaînes (ordre alphabétique/lexicographique)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# La comparaison de chaînes est sensible à la casse
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Comparer les longueurs de chaînes avec len()
print(len(name1) == len(name2))  # Output: False

Lors de la comparaison de chaînes, Python utilise l’ordre lexicographique, qui est essentiellement l’ordre alphabétique basé sur les valeurs Unicode des caractères. Les lettres majuscules viennent avant les lettres minuscules dans cet ordre, ce qui explique pourquoi "Python" et "python" ne sont pas égaux.

7.2.3) Stocker les résultats de comparaison

Le résultat de toute comparaison est une valeur booléenne, ce qui signifie que vous pouvez la stocker dans une variable :

python

# storing_comparisons.py
# Stockage des résultats de comparaison pour une utilisation ultérieure
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Nous verrons bientôt les comparaisons chaînées
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Utiliser des comparaisons stockées dans des calculs ou d'autres expressions
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Stocker les résultats de comparaison dans des variables au nom explicite rend votre code plus lisible. Au lieu d'écrire plusieurs fois age >= 18 dans votre programme, vous pouvez utiliser la variable is_adult, qui communique clairement ce que vous vérifiez.

7.3) Booléens issus de comparaisons, d’expressions et de la fonction bool()

Nous avons vu que les comparaisons produisent des valeurs booléennes. Mais il existe d'autres façons d'obtenir des valeurs booléennes en Python, notamment en utilisant la fonction bool() pour convertir d'autres types en booléens.

7.3.1) La fonction bool()

La fonction bool() convertit n'importe quelle valeur en son équivalent booléen. Elle est utile lorsque vous voulez vérifier explicitement si une valeur serait considérée comme vraie ou fausse dans un contexte booléen :

python

# bool_function.py
# Conversion de nombres en booléens
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Conversion de chaînes en booléens
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Conversion de None en booléen
print(bool(None))    # Output: False

La fonction bool() suit des règles spécifiques de conversion, que nous explorerons en détail dans la prochaine section sur la truthiness et la falsiness. Pour l'instant, remarquez que la plupart des valeurs sont converties en True, mais certaines valeurs particulières comme 0, 0.0, les chaînes vides ("") et None sont converties en False.

7.4) Truthiness et falsiness dans les conditions

L'une des fonctionnalités les plus puissantes de Python est sa notion de truthiness et de falsiness. En Python, chaque valeur — pas seulement True et False — possède une interprétation booléenne intrinsèque. Cela signifie que vous pouvez utiliser n'importe quelle valeur là où un booléen est attendu, et Python la traitera comme vraie ou fausse.

7.4.1) Valeurs falsy : ce qui est considéré comme faux

En Python, les valeurs suivantes sont considérées comme falsy (elles se comportent comme False dans les contextes booléens) :

La valeur booléenne False elle-même
La valeur spéciale None
Zéro sous toutes ses formes : 0, 0.0, 0j (zéro complexe)
Les séquences vides : "" (chaîne vide), [] (liste vide), () (tuple vide)
Les mappings vides : {} (dictionnaire vide)
Les ensembles vides : set()

Vérifions cela avec la fonction bool() :

python

# falsy_values.py
# Toutes ces valeurs sont falsy
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Valeurs truthy : tout le reste

Toutes les autres valeurs en Python sont considérées comme truthy (elles se comportent comme True dans les contextes booléens). Cela inclut :

La valeur booléenne True elle-même
Tout nombre non nul (positif ou négatif)
Toute chaîne, liste, tuple, dictionnaire ou ensemble non vide
La plupart des objets que vous créez

python

# truthy_values.py
# Toutes ces valeurs sont truthy
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Remarque importante : La chaîne "False" est truthy car c'est une chaîne non vide. La chaîne "0" est également truthy pour la même raison. Seule la valeur booléenne False et la valeur numérique 0 sont falsy.

7.4.3) Pourquoi la truthiness est importante

Comprendre la truthiness est important car c'est un concept fondamental de Python que vous rencontrerez souvent. Au chapitre 8, vous verrez les instructions if qui prennent des décisions en fonction de conditions. Ces instructions peuvent utiliser n'importe quelle valeur, pas seulement des comparaisons booléennes explicites, car Python évalue automatiquement la truthiness des valeurs.

La truthiness vous permet d'écrire un code concis qui vérifie si des collections contiennent des éléments, si des chaînes ont du contenu ou si des valeurs optionnelles sont présentes. Voici un aperçu de l'utilité de la truthiness (nous apprendrons la syntaxe complète de l'instruction if au chapitre 8) :

python

# truthiness_preview.py
# Démonstration de la truthiness avec bool()
# (Au chapitre 8, nous utiliserons ces valeurs directement dans des instructions if)
 
# Vérifier si une chaîne a du contenu
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Vérifier si une liste contient des éléments
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Vérifier si une valeur existe (n'est pas None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

Comprendre la truthiness rend votre code plus « Pythonique » — il suit les conventions et idiomes de Python. Lorsque vous voyez des programmeurs Python expérimentés vérifier des conditions sans comparaisons explicites, ils tirent parti de la truthiness pour écrire un code plus clair et plus lisible.

7.5) Comparaisons chaînées et pièges courants avec les booléens

Python offre une fonctionnalité puissante appelée comparaisons chaînées qui rend certaines conditions plus lisibles et plus proches de la notation mathématique. Cependant, cette fonctionnalité et d'autres aspects de la logique booléenne peuvent aussi mener à des erreurs fréquentes.

7.5.1) Comparaisons chaînées

En mathématiques, vous pouvez écrire « 10 < x < 20 » pour exprimer que x est compris entre 10 et 20. Python vous permet d'écrire cela exactement de la même manière :

python

# chained_comparisons.py
# Vérifier si une valeur est dans un intervalle
x = 15
 
# Façon mathématique (comparaison chaînée)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Ceci équivaut à combiner deux comparaisons
# (Nous verrons 'and' au chapitre 9)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Test avec une valeur hors de l'intervalle
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Test avec des valeurs aux bornes
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Inclure les bornes avec <= et >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

Les comparaisons chaînées fonctionnent en évaluant chaque paire d'éléments adjacents. L'expression 10 < x < 20 est évaluée comme (10 < x) and (x < 20). Toutes les comparaisons doivent être vraies pour que l'ensemble de la chaîne soit vrai.

Vous pouvez chaîner plus de deux comparaisons :

python

# multiple_chains.py
# Chaîner plusieurs comparaisons
a = 5
b = 10
c = 15
d = 20
 
# Vérifier si les valeurs sont dans l'ordre croissant
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Voici une représentation visuelle du fonctionnement des comparaisons chaînées :

7.5.2) Piège courant : affectation vs comparaison

L'une des erreurs les plus fréquentes chez les débutants est d'utiliser l'affectation (=) lorsqu'ils veulent faire une comparaison (==) :

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Ceci est une affectation, pas une comparaison
# Cela affecte 20 à x, au lieu de comparer x à 20
# x = 20  # Ceci changerait x à 20
 
# Ceci est une comparaison
result = (x == 20)  # Ceci vérifie si x est égal à 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# Au chapitre 8, vous verrez qu'utiliser = dans une condition provoque une erreur
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# La comparaison correcte
# Au chapitre 8, vous écrirez : if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python aide à prévenir cette erreur dans les instructions if (que vous verrez au chapitre 8) en levant une SyntaxError si vous utilisez une affectation au lieu d'une comparaison. Cependant, dans d'autres contextes, utiliser = alors que vous vouliez == peut créer des bogues subtils et difficiles à détecter.

7.5.3) Piège courant : comparaisons de nombres flottants

Lorsque vous comparez des nombres flottants, vous devez être conscient des problèmes de précision :

python

# floating_point_comparison.py
# Les opérations en virgule flottante peuvent avoir des problèmes de précision
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Une comparaison directe peut ne pas fonctionner comme prévu
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# La valeur réelle est très proche mais pas exactement 0.3
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Pour les comparaisons en virgule flottante, utilisez une petite tolérance
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+ fournit math.isclose() pour cela
# Nous verrons l'import de modules au chapitre 23
# import math
# is_close = math.isclose(result, 0.3)

Ce problème provient du fait que les ordinateurs stockent les nombres flottants en binaire, et que certains nombres décimaux (comme 0.1) ne peuvent pas être représentés exactement en binaire. Lorsque vous effectuez des opérations arithmétiques avec ces nombres, de petites erreurs d'arrondi s'accumulent. Pour la plupart des usages pratiques, ces erreurs sont négligeables, mais elles peuvent faire échouer des comparaisons d'égalité directe de manière inattendue.

7.6) Booléens comme entiers (1 et 0) et pourquoi éviter l'arithmétique

Voici un fait surprenant : en Python, True et False sont en réalité des cas particuliers d'entiers. True est équivalent à 1, et False est équivalent à 0. Il s'agit d'un artefact historique de la conception de Python, mais cela a des implications intéressantes. Comprendre cette relation vous aide à éviter la confusion, mais vous devriez rarement l'utiliser directement dans votre code.

7.6.1) Les booléens sont des entiers

Vous pouvez vérifier que les booléens sont des entiers en contrôlant leur type et en effectuant des opérations entières :

python

# booleans_as_integers.py
# Les booléens sont un sous-type des entiers
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True vaut 1, False vaut 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Vous pouvez utiliser les booléens dans des opérations arithmétiques (mais vous ne devriez pas !)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Les booléens peuvent être utilisés comme indices de liste
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

La fonction isinstance() vérifie si une valeur est une instance d'un type. Lorsque nous appelons isinstance(True, int), Python renvoie True car le type bool est un sous-classe de int.

7.6.2) Pourquoi éviter l'arithmétique avec les booléens

Même si Python vous permet d'utiliser des booléens dans des opérations arithmétiques, vous devriez éviter de le faire. Utiliser des booléens comme des nombres rend votre code déroutant et plus difficile à comprendre. La relation entre booléens et entiers est surtout un détail historique que vous devriez connaître, mais rarement exploiter directement.

Voici pourquoi l'arithmétique avec les booléens pose problème :

python

# boolean_arithmetic_problems.py
# Exemple de code déroutant
count = 0
has_error = True
has_warning = False
 
# Ceci fonctionne mais est déroutant
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# Qu'est-ce que cela signifie ? Ce n'est pas clair !
# Meilleure approche : être explicite
# Nous verrons l'expression if-else au chapitre 10.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

La seule exception courante à cette règle est le comptage de valeurs True dans une collection :

python

# counting_trues.py
# Compter combien de conditions sont vraies
conditions = [True, False, True, True, False]
 
# Ceci est acceptable car l'intention est claire
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Ceci fonctionne car sum() additionne les valeurs
# True est traité comme 1, False comme 0
# Donc sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

Dans ce cas, utiliser sum() sur une liste de booléens est un idiome Python courant et bien compris. L'intention — compter combien de conditions sont vraies — est claire d'après le contexte.

7.6.3) Booléens et conversion de type

Comme les booléens sont des entiers, les convertir explicitement en entiers est redondant :

python

# boolean_conversion.py
# Conversion de booléens en entiers (inutile)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Mais convertir des entiers en booléens est utile
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

Convertir un booléen en entier avec int() est inutile car les booléens se comportent déjà comme des entiers. En revanche, convertir des entiers (ou d'autres types) en booléens avec bool() est utile lorsque vous voulez vérifier explicitement la truthiness.

7.6.4) La raison historique

La raison pour laquelle les booléens sont des entiers en Python est historique. Les premières versions de Python (avant la version 2.3) n'avaient pas de type booléen séparé. Les programmeurs utilisaient 1 pour vrai et 0 pour faux. Lorsque le type bool a été ajouté, il a été rendu sous-classe de int pour maintenir la compatibilité avec le code existant.

Aujourd'hui, vous devriez considérer True et False avant tout comme des valeurs booléennes. Leur relation à 1 et 0 est un détail d'implémentation auquel vous aurez rarement besoin de penser, sauf lorsque vous le rencontrez dans des cas inattendus.

7.7) Utiliser in et not in dans les conditions

Les opérateurs in et not in testent l'appartenance — c'est-à-dire si une valeur existe dans une collection. Ces opérateurs sont extrêmement utiles pour créer des conditions lisibles, en particulier lorsque vous travaillez avec des chaînes, des listes et d'autres collections.

7.7.1) Tester l'appartenance dans les chaînes

L'opérateur in vérifie si une chaîne apparaît dans une autre chaîne :

python

# string_membership.py
# Vérifier si une sous-chaîne existe dans une chaîne
text = "Python programming is fun"
 
# Utiliser 'in' pour vérifier des sous-chaînes
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Correspondance sensible à la casse
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Utiliser 'not in' pour vérifier l'absence
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

L'opérateur in effectue une recherche sensible à la casse. Si vous avez besoin d'une recherche insensible à la casse, vous pouvez convertir les deux chaînes dans la même casse :

python

# case_insensitive_search.py
text = "Python Programming"
 
# Recherche sensible à la casse (ne correspond pas)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Recherche insensible à la casse (conversion des deux en minuscules)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# La chaîne originale n'est pas modifiée
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Tester l'appartenance dans les listes

L'opérateur in fonctionne aussi avec les listes (que nous verrons en détail au chapitre 14) :

python

# list_membership.py
# Vérifier si une valeur existe dans une liste
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# Utiliser 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Fonctionne avec des chaînes dans les listes
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Test d'appartenance avec les ranges

Vous pouvez également utiliser in avec des objets range (que nous verrons au chapitre 12) :

python

# range_membership.py
# Vérifier si un nombre est dans un range
age = 25
 
# Utiliser 'in' avec range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Cependant, les opérateurs de comparaison sont plus efficaces pour les intervalles numériques
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' avec range est utile pour des séquences spécifiques
valid_ages = range(18, 66)  # Tranche d'âge de travail
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) L'opérateur not in

L'opérateur not in est l'opposé de in — il renvoie True si la valeur n'est PAS trouvée dans la collection :

python

# not_in_operator.py
# Utiliser 'not in' pour une logique plus claire
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Utiliser 'not in' est plus lisible
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Vérifier l'absence de champs obligatoires
provided_fields = ["name", "email"]
 
# Trouver les champs manquants
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Les opérateurs in et not in rendent vos conditions plus lisibles et expressives. Au lieu d'écrire des comparaisons complexes, vous pouvez exprimer directement « cette valeur est-elle dans cette collection ? », ce qui correspond à la façon dont vous pensez le problème.

Dans ce chapitre, vous avez appris les bases des valeurs booléennes et des conditions en Python. Vous comprenez maintenant :

Les valeurs booléennes True et False et leur rôle dans la prise de décision
Les opérateurs de comparaison (==, !=, <, >, <=, >=) pour créer des conditions
La fonction bool() pour convertir des valeurs en booléens
La truthiness et la falsiness — comment Python traite toutes les valeurs comme vraies ou fausses
Les comparaisons chaînées pour des vérifications d'intervalles lisibles
Les pièges courants à éviter lorsque vous travaillez avec les booléens
La relation entre les booléens et les entiers (et pourquoi éviter l'arithmétique booléenne)
Le test d'appartenance avec les opérateurs in et not in

Ces concepts constituent la base des structures de contrôle que vous verrez dans les prochains chapitres. Au chapitre 8, vous utiliserez des expressions booléennes dans des instructions if pour que vos programmes réagissent à différentes conditions. Au chapitre 9, vous apprendrez à combiner plusieurs conditions avec des opérateurs logiques comme and, or et not. Et aux chapitres 10 et 11, vous utiliserez des conditions pour contrôler des boucles qui répètent des actions.

Comprendre les booléens et les conditions est essentiel pour écrire des programmes capables de prendre des décisions, de valider des entrées et de réagir correctement à différentes situations. En vous exerçant avec ces concepts, vous constaterez que la prise de décision en Python devient naturelle et intuitive.