Partie 4 : Booléens et expressions booléennes

Programme officiel (B.O.)

B.O. spécial n° 1 du 22 janvier 2019 - NSI Première

Contenus	Capacités attendues	Commentaires
Valeurs booléennes : 0, 1. Opérateurs booléens : and, or, not. Expressions booléennes	Dresser la table d'une expression booléenne.	Le ou exclusif (xor) est évoqué. Quelques applications directes comme l'addition binaire sont présentées. L'attention des élèves est attirée sur le caractère séquentiel de certains opérateurs booléens.

---

1. Les valeurs booléennes

1.1 Origine historique

Le mathématicien anglais George Boole (1815-1864) a développé une algèbre permettant de formaliser le raisonnement logique avec seulement deux valeurs : vrai et faux. Cette algèbre, devenue l'algèbre de Boole, est le fondement de toute l'informatique moderne.

1.2 En informatique

Un booléen est un type de donnée qui ne peut prendre que deux valeurs :

Valeur logique	En Python	En binaire
Vrai	True	1
Faux	False	0

En Python, le type booléen s'appelle bool :

>>> type(True)
<class 'bool'>

>>> type(False)
<class 'bool'>

1.3 Expressions produisant des booléens

Les opérateurs de comparaison renvoient des booléens :

>>> 5 > 3
True

>>> 10 == 7
False

>>> "alice" != "bob"
True

>>> 4 <= 4
True

Opérateur	Signification
==	Égal à
!=	Différent de
<	Strictement inférieur
>	Strictement supérieur
<=	Inférieur ou égal
>=	Supérieur ou égal

---

2. Les opérateurs booléens

2.1 L'opérateur NOT (non)

L'opérateur not inverse une valeur booléenne : vrai devient faux, et faux devient vrai.

Table de vérité :

a	not a
0	1
1	0

>>> not True
False

>>> not False
True

>>> not (5 > 3)
False

2.2 L'opérateur AND (et)

L'opérateur and renvoie True uniquement si les deux opérandes sont vrais. Il suffit qu'un seul soit faux pour que le résultat soit faux.

Table de vérité :

a	b	a and b
0	0	0
0	1	0
1	0	0
1	1	1

>>> True and True
True

>>> True and False
False

>>> (5 > 3) and (10 < 20)
True

>>> (5 > 3) and (10 > 20)
False

Moyen mnémotechnique

and est comme une multiplication : 1 × 1 = 1, tout le reste donne 0.

2.3 L'opérateur OR (ou)

L'opérateur or renvoie True si au moins un des opérandes est vrai. Il ne renvoie False que si les deux sont faux.

Table de vérité :

a	b	a or b
0	0	0
0	1	1
1	0	1
1	1	1

>>> False or True
True

>>> False or False
False

>>> (5 > 10) or (3 < 7)
True

Attention

Le or en logique est un « ou inclusif » : il renvoie vrai même si les deux conditions sont vraies. C'est différent du « ou » du langage courant (« fromage ou dessert ») qui est souvent exclusif.

---

3. Le ou exclusif (XOR)

Le ou exclusif (noté XOR ou ⊕) renvoie True si exactement un des deux opérandes est vrai, mais pas les deux.

Table de vérité :

a	b	a XOR b
0	0	0
0	1	1
1	0	1
1	1	0

La différence avec le or est visible sur la dernière ligne : 1 XOR 1 = 0.

En Python, le XOR s'écrit avec l'opérateur ^ (sur les entiers) :

>>> 1 ^ 0
1

>>> 1 ^ 1
0

>>> True ^ True
False

>>> True ^ False
True

À retenir

Le XOR correspond au « ou » exclusif du langage courant : « fromage ou dessert » (l'un ou l'autre, mais pas les deux).

---

4. Dresser la table de vérité d'une expression

Pour une expression booléenne complexe, on construit sa table de vérité en listant toutes les combinaisons possibles des variables d'entrée.

Exemple : table de vérité de (a and b) or (not a)

Avec 2 variables, il y a 2² = 4 combinaisons :

a	b	not a	a and b	(a and b) or (not a)
0	0	1	0	1
0	1	1	0	1
1	0	0	0	0
1	1	0	1	1

Exemple : table de vérité de not (a and b)

a	b	a and b	not (a and b)
0	0	0	1
0	1	0	1
1	0	0	1
1	1	1	0

On remarque que not (a and b) donne le même résultat que (not a) or (not b). C'est une des lois de De Morgan.

Lois de De Morgan

Ces deux équivalences sont très utiles pour simplifier des expressions :

• not (a and b) = (not a) or (not b)
• not (a or b) = (not a) and (not b)

En termes simples : quand on « distribue » un not sur un and ou un or, l'opérateur s'inverse.

---

5. L'évaluation paresseuse (court-circuit)

Python évalue les expressions booléennes de gauche à droite et s'arrête dès que le résultat est déterminé. C'est l'évaluation paresseuse (ou évaluation en court-circuit).

5.1 Court-circuit avec and

Si le premier opérande est False, Python sait que le résultat sera False quel que soit le second opérande. Il ne l'évalue pas.

>>> False and (1 / 0 > 0)    # pas d'erreur de division par 0 !
False

La division par zéro n'est jamais exécutée car Python s'arrête après avoir évalué False.

5.2 Court-circuit avec or

Si le premier opérande est True, Python sait que le résultat sera True quel que soit le second opérande.

>>> True or (1 / 0 > 0)    # pas d'erreur non plus !
True

5.3 Application pratique

L'évaluation paresseuse est très utile pour écrire des conditions de sécurité :

def element_existe(liste, index):
    """Vérifie si l'élément à l'index donné existe et vaut 0."""
    if index < len(liste) and liste[index] == 0:
        return True
    return False

Si index dépasse la taille de la liste, le and court-circuite et liste[index] n'est jamais évalué : on évite une erreur IndexError.

Attention

L'ordre des conditions dans un and ou un or peut avoir de l'importance. La condition la plus « protectrice » doit être placée en premier.

---

6. Application : l'addition binaire

Les opérations booléennes sont au fondement des circuits électroniques des processeurs. L'addition de deux bits illustre ce lien.

6.1 Le demi-additionneur

L'addition de deux bits A et B produit :

• Une somme S ;
• Une retenue R (en anglais carry).

A	B	Somme (S)	Retenue (R)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

En comparant avec les tables de vérité :

• S = A XOR B (la somme vaut 1 quand les bits sont différents) ;
• R = A AND B (la retenue vaut 1 quand les deux bits valent 1).

C'est ainsi que les processeurs additionnent les nombres : avec des portes logiques XOR et AND connectées entre elles.

6.2 Exemple complet : addition binaire

Additionnons $(1011)_2$ et $(0110)_2$ (soit 11 + 6 = 17) :

  retenues :  1 1 1 0
               1 0 1 1   (11)
             + 0 1 1 0   (6)
             ---------
             1 0 0 0 1   (17)

Le procédé est identique à l'addition en décimal, mais les retenues se propagent dès que la somme dépasse 1.

---

7. Résumé

Opérateur	Python	Description	Résultat = 1 si...
NON	not a	Négation	a est faux
ET	a and b	Conjonction	a et b sont tous les deux vrais
OU	a or b	Disjonction	Au moins un des deux est vrai
XOR	a ^ b	Ou exclusif	Exactement un des deux est vrai

Propriété	Détail
Lois de De Morgan	not (a and b) = (not a) or (not b) et inversement
Évaluation paresseuse	Python s'arrête dès que le résultat est déterminé
Addition binaire	Somme = XOR, Retenue = AND
Table de vérité	Avec n variables, il y a 2ⁿ lignes