Comprendre les booléens Python

Un boolean est un type de données qui ne peut prendre que deux valeurs : True ou False. Les booléens Python contrôlent chaque décision prise par votre code — des instructions if aux boucles while en passant par les compréhensions de listes. Ce chapitre explique le fonctionnement des booléens, la façon dont Python évalue n'importe quelle valeur comme truthy ou falsy, ainsi que des schémas pratiques que vous utiliserez au quotidien.

Que sont les booléens Python ?

En Python, True et False sont des mots-clés (avec une majuscule). Ils appartiennent au type intégré bool, qui est une sous-classe de int. Cela signifie que True se comporte comme 1 et False comme 0 dans les contextes arithmétiques.

print(type(True))   # <class 'bool'>
print(type(False))  # <class 'bool'>

print(True == 1)    # True
print(False == 0)   # True
print(True + True)  # 2  (bool is a subclass of int)

La dernière ligne — True + True qui donne 2 — surprend de nombreux débutants. C'est du Python valide et parfois utile (par exemple, pour compter combien de conditions dans une liste sont vraies), mais l'utilisation des booléens en arithmétique doit être intentionnelle et clairement commentée.

Créer des variables booléennes

Vous pouvez assigner True ou False directement à une variable :

Python define boolean variable

Par convention, les noms de variables booléennes commencent souvent par is_, has_, can_ ou should_ afin de clarifier leur rôle en un coup d'œil.

Booléens issus des opérateurs de comparaison

Chaque opérateur de comparaison produit un résultat booléen :

Python compare two integers

Vous pouvez stocker les résultats des comparaisons dans une variable et les réutiliser, ce qui améliore la lisibilité des conditions if complexes.

Utiliser les booléens dans les instructions conditionnelles

Les booléens sont le moteur des décisions if/else. Python évalue l'expression qui suit if et exécute le bloc indenté uniquement lorsque le résultat est True :

Python compare two integers and print the result

Vous pouvez aussi utiliser directement une variable booléenne sans aucun opérateur de comparaison :

is_raining = True
if is_raining:
    print("Bring an umbrella")
else:
    print("Enjoy the sunshine")

Écrire if is_raining: est plus pythonique que if is_raining == True:. La seconde forme n'apporte aucune information supplémentaire et est considérée comme une mauvaise pratique.

Valeurs truthy et falsy

Python n'exige pas une valeur True ou False littérale dans un contexte booléen. Chaque objet est soit truthy (traité comme True) soit falsy (traité comme False). Cela permet d'écrire des conditions concises sans comparaisons explicites.

Valeurs falsy

Les valeurs suivantes sont toujours falsy en Python :

Tout le reste est truthy — y compris les nombres non nuls, les strings non vides et les collections non vides.

# All of these print "empty" because the values are falsy
for value in [0, 0.0, "", [], {}, (), None]:
    if not value:
        print(f"{repr(value)} is falsy")

Valeurs truthy en pratique

name = input("Enter your name: ")
if name:                   # truthy if name is not an empty string
    print(f"Hello, {name}!")
else:
    print("No name provided.")

items = [1, 2, 3]
if items:                  # truthy if list is not empty
    print(f"Processing {len(items)} items")

Ce schéma — vérifier directement une collection plutôt que len(items) > 0 — est idiomatique en Python.

Convertir des valeurs en boolean avec bool()

La fonction intégrée bool() convertit n'importe quelle valeur en son équivalent booléen, ce qui est utile lorsque vous souhaitez savoir si quelque chose est truthy ou falsy :

Python casting into boolean

Autres exemples :

print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False
print(bool([]))       # False
print(bool(None))     # False

print(bool(1))        # True
print(bool(-1))       # True
print(bool("hello"))  # True
print(bool([0]))      # True  — list with one element is truthy

Notez que bool([0]) est True même si l'unique élément à l'intérieur est falsy. Python vérifie si le conteneur est vide, pas les valeurs qu'il contient.

Opérateurs logiques avec les booléens

Python fournit trois opérateurs logiques pour combiner des expressions booléennes. Consultez Python Operators pour la référence complète des opérateurs.

and

Retourne True uniquement si les deux opérandes sont vrais :

print(True and True)   # True
print(True and False)  # False
print(False and True)  # False
print(False and False) # False

or

Retourne True si au moins un opérande est vrai :

print(True or False)   # True
print(False or False)  # False
print(True or True)    # True

not

Inverse la valeur booléenne :

print(not True)   # False
print(not False)  # True
print(not 0)      # True  (0 is falsy, so not 0 is True)
print(not "hi")   # False ("hi" is truthy, so not "hi" is False)

Évaluation en court-circuit

Python évalue and et or de manière paresseuse — il s'arrête dès que le résultat est déterminé. C'est ce qu'on appelle l'évaluation en court-circuit :

• False and <anything> — Python n'évalue jamais le côté droit car le résultat est déjà False.
• True or <anything> — Python n'évalue jamais le côté droit car le résultat est déjà True.

Cela est important lorsque le côté droit a des effets de bord ou pourrait lever une erreur :

items = []

# Safe: the second condition is only evaluated if items is truthy
if items and items[0] > 10:
    print("First item exceeds 10")

Sans court-circuit, items[0] sur une liste vide lèverait une IndexError. Comme items est falsy (liste vide), Python ignore entièrement le côté droit.

L'opérateur is vs. == avec les booléens

== teste si deux valeurs sont égales. is teste si deux noms font référence au même objet en mémoire.

print(1 == True)   # True  (equal in value)
print(1 is True)   # False (different objects)

Utilisez toujours == (ou fiez-vous à la truthiness) pour comparer des valeurs. Réservez is aux vérifications d'identité — le plus souvent is None :

value = None
if value is None:
    print("No value provided")

== None fonctionne, mais is None est la forme idiomatique et légèrement plus rapide.

Compter avec les booléens

Puisque True == 1 et False == 0, vous pouvez utiliser sum() pour compter combien d'éléments d'une liste satisfont une condition :

scores = [85, 42, 91, 67, 55, 78]
passed = sum(score >= 60 for score in scores)
print(f"{passed} out of {len(scores)} students passed")
# 4 out of 6 students passed

C'est plus concis qu'une boucle avec compteur manuel et constitue un idiome Python courant.

Pièges courants

1. Comparer explicitement avec True/False

# Avoid
if is_valid == True:
    ...

# Prefer
if is_valid:
    ...

2. Confondre = (affectation) et == (égalité)

x = 5
if x = 5:   # SyntaxError — use == for comparison
    print("equal")

3. Supposer qu'une liste vide à l'intérieur d'une liste est falsy

outer = [[]]       # a list containing one empty list
if outer:
    print("truthy")  # This prints! outer has one element.

La liste externe contient un élément (la liste vide interne), donc outer est elle-même truthy. Seule la liste interne outer[0] est falsy.

Résumé

• Les booléens Python sont True et False — toujours avec une majuscule.
• Chaque valeur en Python est soit truthy soit falsy. Les valeurs falsy comprennent 0, "", [], {}, () et None.
• Utilisez bool() pour convertir explicitement une valeur en son équivalent booléen.
• Combinez les conditions avec and, or et not. Python les évalue de manière paresseuse grâce aux règles de court-circuit.
• Utilisez is None (et non == None) pour vérifier la valeur None.
• Puisque bool est une sous-classe de int, True + True est égal à 2 — pratique pour compter.

Ensuite, apprenez les opérateurs Python pour voir comment les opérateurs de comparaison et logiques produisent les valeurs booléennes abordées ici. Vous pouvez aussi explorer comment les booléens pilotent le flux d'un programme dans Python If...Else.

Pratique