cours1 min de lecture

Valeurs booléennes et opérateurs logiques

Le calcul à deux états — vrai ou faux — qui structure toute condition et tout test en programmation.

programme

Introduction

Tout programme prend, à un moment ou un autre, des décisions : « si ce nombre est positif, faire ceci, sinon cela ». Ces décisions s'appuient sur des conditions, qui ne peuvent avoir que deux résultats : vrai ou faux.

Cette logique binaire, formalisée au XIXᵉ siècle par le mathématicien anglais George Boole, porte aujourd'hui son nom : on parle d'algèbre de Boole et de valeurs booléennes. Elle est partout en informatique — des tests d'égalité jusqu'aux portes logiques qui constituent physiquement le processeur.

En Python, ces deux valeurs s'écrivent True et False (avec une majuscule initiale, c'est important).

Les trois opérateurs de base

L'algèbre de Boole repose sur trois opérateurs principaux. En Python, ils s'écrivent en toutes lettres.

Opérateur logique	Python	Notation mathématique	Effet
ET	`and`	$\land$	vrai si les deux opérandes sont vrais
OU	`or`	$\lor$	vrai si au moins un des opérandes est vrai
NON	`not`	$\lnot$	inverse la valeur

⏵ Ctrl+↵ pour exécuter

Aucune exécution pour l'instant.

Sortie attendue :

False
True
False
False

Tables de vérité

Une table de vérité énumère toutes les combinaisons possibles des opérandes et donne la valeur du résultat. C'est l'outil de référence pour analyser une expression booléenne.

`and` (ET logique)

$A$	$B$	$A \land B$
Faux	Faux	Faux
Faux	Vrai	Faux
Vrai	Faux	Faux
Vrai	Vrai	Vrai

`or` (OU logique)

$A$	$B$	$A \lor B$
Faux	Faux	Faux
Faux	Vrai	Vrai
Vrai	Faux	Vrai
Vrai	Vrai	Vrai

`not` (NON logique)

$A$	$\lnot A$
Faux	Vrai
Vrai	Faux

Pour

n

variables booléennes, la table de vérité contient

2^n

lignes — toutes les combinaisons possibles. Pour 3 variables, 8 lignes ; pour 4 variables, 16. La taille double à chaque ajout.

Le ou exclusif — `xor`

Il existe un quatrième opérateur très utile : le ou exclusif, noté xor ou $\oplus$ . Il vaut vrai si exactement un des opérandes est vrai (et donc faux si les deux sont identiques).

$A$	$B$	$A \oplus B$
Faux	Faux	Faux
Faux	Vrai	Vrai
Vrai	Faux	Vrai
Vrai	Vrai	Faux

Python ne fournit pas d'opérateur xor en toutes lettres pour les booléens, mais on peut l'écrire avec != :

A, B = True, False
print(A != B)   # True — équivaut à A xor B

Le xor est très utile pour l'addition binaire : sur 1 bit, $1 \oplus 1$ vaut 0 avec une retenue. C'est exactement ce dont a besoin un additionneur matériel.

Quel opérateur retourne vrai uniquement si A et B sont différents ?

Expressions booléennes

On peut composer des expressions plus complexes en combinant and, or, not. Comme en arithmétique, l'ordre des opérations compte :

not est appliqué en premier (priorité la plus haute).
Puis and.
Puis or (priorité la plus basse).

Exemple : pour évaluer True or False and not False, on lit dans cet ordre :

not False → True
False and True → False
True or False → True

En cas de doute, mettez des parenthèses. Elles ne coûtent rien et clarifient la lecture du code :

if (age >= 18) and (permis or accompagnateur):
    conduire()

Que vaut not (True or False) ?

Sans parenthèses, que vaut True or False and False (rappel : and est prioritaire sur or) ?

Le caractère séquentiel des opérateurs

Une particularité importante : Python évalue les opérateurs booléens de gauche à droite, et il s'arrête dès qu'il connaît le résultat. On parle d'évaluation paresseuse ou séquentielle.

Pour A and B : si A est faux, le résultat est forcément faux. Python ne va même pas évaluer B.
Pour A or B : si A est vrai, le résultat est forcément vrai. Python ne va même pas évaluer B.

Cette propriété est exploitée comme une protection courante :

liste = []
# Sans court-circuit, on aurait une erreur en accédant à liste[0]
if liste and liste[0] > 5:
    print("Premier élément grand")

Si liste est vide, liste est considéré comme faux, et Python ne tente même pas d'évaluer liste[0] qui aurait planté.

Cette évaluation séquentielle peut surprendre quand un opérande contient un effet de bord (appel de fonction, modification d'une variable). L'effet ne se produira pas si l'opérande n'est pas évalué. Toujours en avoir conscience.

Une application directe — l'addition binaire

L'addition de deux bits se décompose élégamment avec xor et and :

Le bit de résultat est donné par A xor B.
La retenue est donnée par A and B.

$A$	$B$	Somme = $A \oplus B$	Retenue = $A \land B$
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

C'est ce circuit minimal, appelé demi-additionneur, qu'on assemble pour construire l'additionneur complet d'un processeur. La logique booléenne n'est donc pas qu'abstraite : elle est gravée dans le silicium.

Pièges courants

En Python, True et False prennent une majuscule initiale. true (avec t minuscule) n'est pas une valeur valide.
Ne pas confondre = (affectation) et == (test d'égalité) : x = 5 met 5 dans x ; x == 5 teste si x vaut 5 et retourne un booléen.
Sans parenthèses, not a == b se lit not(a == b), pas (not a) == b.
Les opérateurs &, |, ^ existent aussi mais agissent bit à bit sur des entiers — c'est différent de and, or, xor sur des booléens.

Pour aller plus loin

Toute fonction logique, aussi complexe soit-elle, peut être réécrite uniquement avec not, and et or (on parle d'ensemble fonctionnellement complet). En électronique, l'opérateur nand (NON-ET) suffit à lui seul à tout reconstruire — d'où son utilisation massive dans la conception des puces.