Contenu

3.2. Les expressions logiques

Les expressions logiques servent à effectuer des tests sur des valeurs. Elles permettent au programme de prendre des décisions. Ces tests s’effectuent grâce aux opérateurs de comparaison. Une expression logique correspond à la question « est-ce que … ? » et a pour résultat une valeur booléenne, True ou False, répondant respectivement à la question par oui ou par non.

3.2.1. Opérateurs de comparaison

Il existe plusieurs opérateurs permettant de comparer des valeurs.

Opérateurs de comparaison

Opérateur

Fonction

<

plus petit que

>

plus grand que

<=

plus petit que ou égal à

>=

plus grand que ou égal à

==

égal à

!=

différent de

is

identique à

Note

La différence entre les opérateurs == et is sera explorée en détails dans le prochain chapitre. En attendant, vous pouvez ignorer le is et n’utiliser que le ==.

Considérez l’expression ci-dessous.

>>> print(6 == 5)
False

On pose ici la question « est-ce que 6 est égal à 5 ? » et la réponse est non. L’expression 6 == 5 a donc la valeur False, que l’on peut afficher à l’aide de print().

Attention

Il ne faut pas confondre l’opérateur d’affectation =, qui assigne une valeur à une variable, et l’opérateur de comparaison ==, qui teste si deux valeurs sont identiques.

Il est bien entendu possible de stocker le résultat d’une comparaison dans une variable.

>>> result = 4 > 2
>>> print(result)
True

3.2.2. Opérateurs logiques

Il arrive que les opérateurs de comparaison seuls ne suffisent pas à effectuer le test souhaité. Par exemple, il est impossible de tester à l’aide d’une seule comparaison si une valeur entière se situe dans l’intervalle entre deux autres. On aimerait formuler ce test ainsi : « est-ce que l’entier est supérieur au premier ET inférieur au deuxième ? ». Cela revient effectivement à combiner, grâce au ET, deux tests en une seule expression logique. On appelle ce ET un opérateur logique.

Il existe trois différents opérateurs logiques, présentés dans la table ci-dessous.

Opérateurs logiques

Opérateur

Utilisation

Fonction

Priorité

or

expr1 or expr2

vrai si au moins une expression est vraie

1 (faible)

and

expr1 and expr2

vrai si les deux expressions sont vraies

2

not

not expr

vrai si l’expression est fausse (inverse)

3 (élevée)

Comme avec les opérateurs arithmétiques, les opérateurs ont différents niveaux de priorité : not a la plus forte priorité, suivi de and et finalement de or. On peut imposer un ordre d’évaluation entre différentes expressions en utilisant les parenthèses.

Les règles classiques de la logique s’appliquent également. La table ci-dessous en mentionne quelques-unes.

Règles d’équivalence

Expression

Équivalence

not a == b

a != b

not a < b

a >= b

not a > b

a <= b

not not a

a

not (expr1 or expr2)

(not expr1) and (not expr2)

not (expr1 and expr2)

(not expr1) or (not expr2)

Nous pouvons à présent expérimenter avec quelques exemples.

>>> print(3 > 5 and 0 == 0)  # faux car seule la deuxième expression est vraie
False

>>> number = 6 - 2
>>> print(True and not 4 != number)  # vrai car les deux expressions sont vraies
True

>>> gib = 2 ** 30
>>> gb = 10 ** 9
>>> print("Qwerty" == "Qwerty" or gib == gb)  # vrai car la première expression est vraie
True

>>> result = 2 > 4 or (not True and 8 != 2)  # faux car les deux expressions sont fausses
>>> print(result)
False

À ce stade, les expressions logiques n’ont pas encore d’utilité concrète. En effet, on ne sait pas quoi faire du résultat à part l’afficher dans la console ou l’enregistrer dans une variable. Cependant, couplées aux structures de contrôle, ces expressions logiques vont permettre au programme de prendre des décisions au lieu de se dérouler linéairement.