Comprendre la logique booléenne dans Python 3

Introduction

Le type de données Booléen peut être l'une de deux valeurs, soit Vrai soit Faux. Nous utilisons des Booléens en programmation pour faire des comparaisons et déterminer le flux de contrôle dans un programme donné.

Les booléens représentent les valeurs de vérité qui sont associées à la branche logique des mathématiques, qui informe les algorithmes en informatique. Nommé d'après le mathématicien George Boole, le mot booléen commence toujours par un B majuscule. Les valeurs True et False seront également toujours avec un T et un F majuscules respectivement, car ce sont des valeurs spéciales en Python.

Dans ce tutoriel, nous allons examiner ce que vous devez comprendre sur le fonctionnement des booléens en Python, et explorer les opérateurs de comparaison, les opérateurs logiques et les tables de vérité.

Conditions préalables

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n'avez pas d'environnement de programmation configuré, vous pouvez consulter les guides d'installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur, approprié à votre système d'exploitation (Ubuntu, CentOS, Debian, etc.).

Opérateurs de comparaison

En programmation, les opérateurs de comparaison sont utilisés pour comparer des valeurs et évaluer jusqu'à une seule valeur booléenne, soit Vrai, soit Faux.

Le tableau ci-dessous présente les opérateurs de comparaison booléens.

Pour comprendre comment ces opérateurs fonctionnent, assignons deux entiers à deux variables dans un programme Python :

x = 5
y = 8

Dans cet exemple, puisque x a la valeur de 5, il est inférieur à y qui a la valeur de 8.

En utilisant ces deux variables et leurs valeurs associées, passons en revue les opérateurs du tableau ci-dessus. Dans notre programme, nous demanderons à Python d'imprimer si chaque opérateur de comparaison évalue à True ou False. Pour nous aider, nous et d'autres humains, à mieux comprendre cette sortie, nous demanderons également à Python d'imprimer une chaîne pour nous montrer ce qu'il évalue.

x = 5
y = 8

print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)

Lorsque nous exécutons ce programme, nous recevons la sortie suivante.

x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

Selon la logique mathématique, dans chacune des expressions ci-dessus, Python a évalué :

• Est-ce que 5 (x) est égal à 8 (y) ? Faux
• 5 n'est pas égal à 8 ? Vrai
• Est-ce que 5 est moins que 8 ? Vrai
• Est-ce que 5 est plus grand que 8 ? Faux
• Est-ce que 5 est inférieur ou égal à 8 ? Vrai
• N'est-ce pas que 5 est inférieur ou égal à 8 ? Faux

Bien que nous ayons utilisé des entiers ici, nous pourrions les substituer par des valeurs flottantes.

Les chaînes peuvent également être utilisées avec des opérateurs booléens. Elles sont sensibles à la casse à moins que vous n'utilisiez une méthode de chaîne supplémentaire.

Voici comment les chaînes sont comparées avec des opérateurs booléens en pratique :

Sammy = "Sammy"
sammy = "sammy"

print("Sammy == sammy: ", Sammy == sammy)

La sortie du programme ci-dessus renvoie ce qui suit.

Sammy == sammy:  False

La chaîne "Sammy" ci-dessus n'est pas égale à la chaîne "sammy", car elles ne sont pas identiques ; l'une commence par une majuscule S et l'autre par une minuscule s. Mais, si nous ajoutons une autre variable qui est assignée à la valeur de "Sammy", alors elles seront évaluées comme égales :

Sammy = "Sammy"
sammy = "sammy"
also_Sammy = "Sammy"

print("Sammy == sammy: ", Sammy == sammy)
print("Sammy == also_Sammy", Sammy == also_Sammy)

Après avoir exécuté le programme ci-dessus, nous obtiendrons la sortie suivante. Cela signifie que tant que la chaîne est absolument identique (y compris la casse), elles seront évaluées comme égales d'un point de vue de la logique booléenne.

Sammy == sammy:  False
Sammy == also_Sammy:  True

Vous pouvez également utiliser les autres opérateurs de comparaison, y compris > et <, pour comparer deux chaînes. Python comparera ces chaînes lexicalement en utilisant les valeurs ASCII des caractères.

Nous pouvons également évaluer des valeurs booléennes avec des opérateurs de comparaison :

t = True
f = False

print("t != f: ", t != f)

Le programme ci-dessus renverra ce qui suit.

t != f:  True

Comme indiqué dans la sortie ci-dessus, le code que nous avons écrit a évalué que True n'est pas égal à False.

Notez la différence entre les deux opérateurs = et ==.

x = y	# Sets x equal to y
x == y	# Evaluates whether x is equal to y

Le premier, = est l'opérateur d'affectation, qui attribue une valeur à une autre. Le second, == est un opérateur de comparaison qui évalue si deux valeurs sont égales.

Opérateurs Logiques

Il existe trois opérateurs logiques utilisés pour comparer des valeurs. Ils évaluent les expressions à des valeurs booléennes, retournant soit True, soit False. Ces opérateurs sont et, ou et non et sont définis dans le tableau ci-dessous.

x and y

x or y

not x

Les opérateurs logiques sont généralement utilisés pour évaluer si deux expressions ou plus sont vraies ou non. Par exemple, ils peuvent être utilisés pour déterminer si la note est suffisante et que l'élève est inscrit au cours. Si ces deux cas sont vrais, alors l'élève se verra attribuer une note dans le système. Un autre exemple serait de déterminer si un utilisateur est un client actif valide d'un magasin en ligne en fonction de s'il a des crédits en magasin ou a effectué un achat au cours des 6 derniers mois.

Pour comprendre comment fonctionnent les opérateurs logiques, évaluons trois expressions :

print((9 > 7) and (2 < 4))	# Both original expressions are True
print((8 == 8) or (6 != 6))	# One original expression is True
print(not(3 <= 1))			# The original expression is False

True
True
True

Dans le premier cas, print((9 > 7) and (2 < 4)), à la fois 9 > 7 et 2 < 4 évaluent à True puisque l'opérateur and était utilisé.

Dans le deuxième cas, print((8 == 8) or (6 != 6)), puisque 8 == 8 a été évalué à True, cela n'a pas fait de différence que 6 != 6 soit évalué à False parce que l'opérateur or a été utilisé. Si nous avions utilisé l'opérateur and, cela aurait été évalué à False.

Dans le troisième cas, print(not(3 <= 1)), l'opérateur notnie la valeur False que renvoie 3 <=1.

Substituons des flottants aux entiers et visons des évaluations False :

print((-0.2 > 1.4) and (0.8 < 3.1))	# One original expression is False
print((7.5 == 8.9) or (9.2 != 9.2))	# Both original expressions are False		
print(not(-5.7 <= 0.3))				# The original expression is True

Dans l'exemple ci-dessus,

• et doit avoir au moins une expression False qui évalue à Faux,
• ou doit avoir les deux expressions évaluées à False,
• not doit avoir son expression interne vraie pour que la nouvelle expression soit évaluée à faux.

Si les résultats ci-dessus vous semblent confus, nous allons passer en revue quelques tables de vérité ci-dessous pour vous mettre à jour.

Vous pouvez également écrire des instructions composées en utilisant et, ou et non :

not((-0.2 > 1.4) and ((0.8 < 3.1) or (0.1 == 0.1)))

Regardons d'abord l'expression la plus intérieure : (0.8 < 3.1) ou (0.1 == 0.1). Cette expression évalue à Vrai car les deux déclarations mathématiques sont Vraies.

Maintenant, nous pouvons prendre la valeur retournée True et la combiner avec l'expression intérieure suivante : (-0.2 > 1.4) et (True). Cet exemple renvoie False parce que l'énoncé mathématique -0.2 > 1.4 est False, et (False) et (True) retourne False.

Enfin, nous avons l'expression externe : not(False), qui évalue à True, donc la valeur retournée finale si nous imprimons cette déclaration est :

True

Les opérateurs logiques et, ou et non évaluent des expressions et renvoient des valeurs booléennes.

Tables de vérité

Il y a beaucoup à apprendre sur la branche logique des mathématiques, mais nous pouvons apprendre sélectivement une partie de cela pour améliorer notre pensée algorithmique lorsque nous programmons.

Voici des tables de vérité pour l'opérateur de comparaison ==, ainsi que chacun des opérateurs logiques et, ou et non. Bien que vous puissiez les raisonner, il peut également être utile de les mémoriser, car cela peut rendre votre processus de prise de décision en programmation plus rapide.

== Tableau de vérité

ET Tableau de vérité

Table de vérité OU

PAS Tableau de Vérité

Les tables de vérité sont des tables mathématiques courantes utilisées en logique et sont utiles à mémoriser ou à garder à l'esprit lors de la construction d'algorithmes (instructions) en programmation informatique.

Utiliser des opérateurs booléens pour le contrôle de flux

Pour contrôler le flux et les résultats d'un programme sous la forme d'instructions de contrôle de flux, nous pouvons utiliser une condition suivie d'une clause.

Une condition s'évalue à une valeur booléenne de Vrai ou Faux, présentant un point où une décision est prise dans le programme. C'est-à-dire, une condition nous indiquerait si quelque chose s'évalue à Vrai ou Faux.

La clause est le bloc de code qui suit la condition et dicte le résultat du programme. C'est-à-dire que c'est la partie faire ceci de la construction « Si x est vrai, alors fais ceci. »

Le bloc de code ci-dessous montre un exemple d'opérateurs de comparaison travaillant en tandem avec des instructions conditionnelles pour contrôler le flux d'un programme Python :

if grade >= 65:					# Condition
    print("Passing grade")		# Clause

else:
    print("Failing grade")

Ce programme va évaluer si la note de chaque élève est suffisante ou non. Dans le cas d'un élève ayant une note de 83, la première instruction renverra True, et l'instruction d'impression Note suffisante sera déclenchée. Dans le cas d'un élève ayant une note de 59, la première instruction renverra False, donc le programme passera à l'instruction d'impression liée à l'expression else : Note insuffisante.

Parce que chaque objet en Python peut être évalué à True ou False, le guide de style PEP 8 recommande de ne pas comparer une valeur à True ou False car cela est moins lisible et renverra souvent un booléen inattendu. C'est-à-dire que vous devriez éviter d'utiliser if sammy == True: dans vos programmes. Au lieu de cela, comparez sammy à une autre valeur non booléenne qui renverra un booléen.

Les opérateurs booléens présentent des conditions qui peuvent être utilisées pour décider du résultat final d'un programme à travers des instructions de contrôle de flux.

Conclusion

Ce tutoriel a discuté des opérateurs de comparaison et logiques appartenant au type booléen, ainsi que des tables de vérité et de l'utilisation des booléens pour le contrôle du flux de programme.

Vous pouvez en apprendre davantage sur d'autres types de données dans notre tutoriel « Comprendre les types de données » et lire sur les instructions conditionnelles dans notre tutoriel « Comment écrire des instructions conditionnelles ».

Nous avons également un eBook gratuit sur Python, Comment coder en Python, qui peut aider à la fois les débutants et ceux qui ont besoin d'une référence rapide.