UKOnline

Type booléen

On connait déjà deux types de données : les nombres (entiers, flottants et complexes) et les chaines de caractères. Voyons maintenant le type booléen dont les données ne peuvent prendre que deux valeurs différentes : vrai et faux. Un intérêt de ce type de donnée est de pouvoir prendre des décisions dans un programme en définissant des conditions qui seront satisfaites ou non.

En Python, on peut utiliser les mots réservés True et False qui représentent les deux valeurs booléennes possibles. Ces deux valeurs sont du type bool comme on peut le vérifier avec la fonction type.

On peut, par exemple, écrire :

L'exécution de ce programme affiche :

True
<class 'bool'>

Opérateur de comparaison

On ne va évidemment pas se contenter des littéraux True et False, mais on va vouloir construire des expressions booléennes. Pour cela, une première façon de faire consiste à utiliser un opérateur de comparaison. Il en existe au total six en Python, repris à la figure 1.

Description Notation
Égal ==
Différent !=
Strictement plus petit <
Plus petit ou égal <=
Strictement plus grand >
Plus grand ou égal >=
Python propose six opérateurs de comparaison que l'on peut utiliser pour construire des expressions booléennes.

Ces opérateurs permettent de comparer deux valeurs et de tester si elles sont égales ou différentes, ou de savoir si l'une est (strictement) plus petite ou plus grande que l'autre. L'exemple suivant illustre l'utilisation de quelques-uns de ces opérateurs :

La première expression compare deux nombres entiers. La valeur de 12 étant égale à la valeur de l'expression 3 * 4, la variable a reçoit la valeur True. La deuxième expression compare deux chaines de caractères. Comme Eat est strictement plus grand que Drink (il se trouve après dans l'ordre alphabétique), la variable b reçoit la valeur True. Enfin, la troisième expression compare deux booléens. La valeur de la variable a n'étant pas différente de la valeur de la variable b, la variable c reçoit la valeur False.

De manière générale, on ne peut comparer que des valeurs qui sont du même type. Pour comparer deux valeurs de types différents, il faut avant tout effectuer des conversions explicites. Dans l'exemple suivant, qui compare un nombre entier et une chaine de caractères, la première instruction produit une erreur tandis que la seconde, où une conversion explicite en chaine de caractères a eu lieu, est valide :

>>> 19 > 'Hello'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() > str()
>>> str(19) > 'Hello'
False

Opérateur logique

Une seconde façon de construire des expressions booléennes consiste à en combiner plusieurs pour en construire une nouvelle, en utilisant des opérateurs logiques. Python propose trois opérateurs logiques repris à la figure 2.

Description Notation
« non » logique not
« et » logique and
« ou » logique or
Python propose trois opérateurs logiques que l'on peut utiliser pour construire des expressions booléennes à partir d'autres expressions booléennes.

Le premier opérateur logique permet d'inverser la valeur d'une expression booléenne. Appliquée à une expression booléenne qui vaut True, elle produit donc comme valeur False, et inversement :

La valeur de l'expression 8 > 2 valant True, puisque $8$ est strictement plus grand que $2$, la valeur de l'expression not 8 > 2 vaut donc False.

Les deux autres opérateurs logiques combinent deux expressions booléennes. Le résultat du « et » logique ne vaut True que si les deux expressions combinées valent True, et il vaut False sinon. Le résultat du « ou » logique vaut True si au moins une des deux expressions combinées vaut True, et il vaut False sinon.

La figure 3 résume les résultats de ces deux opérateurs, sous la forme d'un tableau appelé table de vérité. Une telle table fournit la valeur d'expressions booléennes composées pour toutes les combinaisons possibles des expressions booléennes sur base desquelles elles sont construites.

a b a and b a or b
False False False False
False True False True
True False False True
True True True True
Les tables de vérité des opérateurs logiques and et or résument le résultat de l'utilisation de ces opérateurs sur des valeurs booléennes.

Voici deux exemples d'expressions booléennes complexes construites avec des opérateurs logiques :

Dans la première expression, la valeur de l'expression à gauche de l'opérateur and est True puisque $8$ est strictement plus grand que $2$, mais celle de l'expression à droite vaut False puisque $12$ n'est pas plus petit ou égal à $4$. Dès lors, la variable a reçoit la valeur False puisque les deux expressions combinées par l'opérateur logique and ne valent pas toutes les deux True.

Pour la seconde expression, l'expression à gauche de l'opérateur or vaut False puisque $5$ n'est pas différent de $5$, et celle de l'expression à droite vaut True puisque la chaine de caractères PY est bien égale à la concaténation des chaines P et Y. Puisqu'au moins une des deux expressions combinées par le or vaut True, la variable b vaut True.

Propriété de court-circuit

Lorsque l'interpréteur Python évalue une expression booléenne contenant des opérateurs and et or, il le fait de manière fainéante, en court-circuitant parfois l'expression à droite de l'opérateur logique. Ce qui se passe, c'est que parfois, en connaissant la valeur de l'expression à gauche de l'opérateur, peu importe celle de l'expression de droite, le résultat final peut déjà être connu.

Si on regarde attentivement les tables de vérités, on se rend compte que si la valeur de a est False, alors a and b vaut False peu importe la valeur de b. De même, si la valeur de a est True, alors a or b vaut True peu importe la valeur de b. Voici deux exemples illustrant cette propriété de court-circuit :

Priorité

Tout comme les opérateurs arithmétiques vus précédemment, les opérateurs de comparaison et les opérateurs logiques possèdent un certain niveau de priorité. Ces opérateurs sont effectués après tout ceux qu'on a déjà rencontrés, dans l'ordre suivant :

  • les quatre comparaisons : <, <=, > et >= ;
  • les égalités : == et != ;
  • le « non » logique : not ;
  • le « et » logique : and ;
  • le « ou » logique : or.

De nouveau, on peut utiliser les parenthèses pour rendre explicite l'ordre dans lequel vous souhaitez qu'une expression soit évaluée. La figure 4 montre quelques exemples d'expressions ainsi que l'expression complètement parenthésée équivalente.

Expression Complètement parenthésée
1 + 2 <= 3 + 4 (1 + 2) <= (3 + 4)
1 - 2 - 3 == 4 + 5 * 6 ((1 - 2) - 3) == (4 + (5 * 6))
not 7 + 3 == 10 not ((7 + 3) == 10)
not 9 > 10 or 1 == 1 (not (9 > 10)) or (1 == 1)
True and 4 < 12 and 1 != -1 (True and (4 < 12)) and (1 != -1)
12 < 1 and False or 4 == 1 + 2 ((12 < 1) and False) or (4 == (1 + 2))
Les règles de priorité des opérateurs définissent l'ordre dans lequel une expression est évaluée, cet ordre pouvant être rendu explicite grâce à des parenthèses.

Enchainement de comparaisons

Enfin, on peut enchainer les opérateurs de comparaison pour effectuer deux opérations de comparaison qui ont en commun une valeur. Prenons, par exemple, une variable x dont on voudrait savoir si sa valeur est comprise entre $0$ et $20$. Pour cela, on peut écrire :

Ce que l'interpréteur va faire, c'est effectuer les comparaisons une à une, les combinant avec un « et » logique. L'instruction ci-dessus équivaut donc à l'expression suivante :

Ce type d'enchainement d'opérateurs de comparaison peut se faire avec n'importe quel opérateur. On peut par exemple écrire l'expression suivante :