Chapitre 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 :
1.3 Expressions produisant des booléens¶
Les opérateurs de comparaison renvoient des booléens :
| 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 |
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 |
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) :
À 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.
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.
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) :
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 |