Comprendre la logique booléenne en Python 3

introduction

Le type de données booléen peut être l'une des deux valeurs, soitTrue ouFalse. Nous utilisons des booléens dans la programmation pour faire des comparaisons et pour contrôler le déroulement du programme.

Les booléens représentent les valeurs de vérité 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 en majuscule. Les valeursTrue etFalse seront également toujours avec respectivement un T et un F majuscule, car ce sont des valeurs spéciales en Python.

Dans ce didacticiel, nous allons passer en revue les bases dont vous aurez besoin pour comprendre le fonctionnement des booléens, y compris la comparaison booléenne et les opérateurs logiques, ainsi que les tables de vérité.

Opérateurs de comparaison

En programmation, les opérateurs de comparaison sont utilisés pour comparer les valeurs et les évaluer avec une seule valeur booléenne True ou False.

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

Opérateur	Ce que cela veut dire
==	Égal à
!=	Pas égal à
<	Moins que
>	Plus grand que
⇐	Inférieur ou égal à
>=	Plus grand ou égal à

Opérateur

Ce que cela veut dire

Égal à

Pas égal à

Moins que

Plus grand que

⇐

Inférieur ou égal à

Plus grand ou égal à

Pour comprendre le fonctionnement de ces opérateurs, assignons deux entiers à deux variables dans un programme Python:

x = 5
y = 8

Nous savons que dans cet exemple, puisquex a la valeur de5, il est inférieur ày qui a la valeur de8.

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’indiquer si chaque opérateur de comparaison a la valeur True ou False. Pour nous aider, ainsi que les autres humains, à mieux comprendre ce résultat, nous demanderons à Python d’imprimer unstring 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)

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

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

Est-ce que 5 (x) est égal à 8 (y)? False
5 n'est pas égal à 8? True
Est-ce que 5 est inférieur à 8? True
Est-ce que 5 est supérieur à 8? False
Est-ce que 5 est inférieur ou égal à 8? True
Est-ce que 5 n'est pas inférieur ou égal à 8? False

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

Les chaînes peuvent également être utilisées avec des opérateurs booléens. Ils sont sensibles à la casse, sauf si vous utilisez unstring method supplémentaire.

Nous pouvons voir comment les chaînes sont comparées dans la pratique:

Sammy = "Sammy"
sammy = "sammy"

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

OutputSammy == sammy:  False

La chaîne"Sammy" ci-dessus n'est pas égale à la chaîne"sammy", car elles ne sont pas exactement les mêmes; l'un commence par unS majuscule et l'autre par uns minuscule. Mais, si nous ajoutons une autre variable à laquelle la valeur"Sammy" est attribuée, alors ils seront évalués comme étant égaux:

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

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

OutputSammy == 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 lexicographiquement en utilisant les valeurs ASCII des caractères.

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

t = True
f = False

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

Outputt != f:  True

Le bloc de code ci-dessus a évalué queTrue 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 définira une valeur égale à une autre. Le second,== est un opérateur de comparaison qui évaluera si deux valeurs sont égales.

Opérateurs logiques

Trois opérateurs logiques sont utilisés pour comparer les valeurs. Ils évaluent les expressions jusqu'à des valeurs booléennes, renvoyant soitTrue, soitFalse. Ces opérateurs sontand,or etnot et sont définis dans le tableau ci-dessous.

Opérateur Ce que cela veut dire À quoi il ressemble

Opérateur	Ce que cela veut dire	À quoi il ressemble
and	Vrai si les deux sont vrais	`x and y`
or	Vrai si au moins un est vrai	`x or y`
not	Vrai seulement si faux	`not x`

and

Vrai si les deux sont vrais

x and y

Vrai si au moins un est vrai

x or y

not

Vrai seulement si faux

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 réussitand que l'étudiant est inscrit dans le cours, et si les deux cas sont vrais, l'étudiant 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'une boutique en ligne en se basant sur le fait qu'il dispose d'un crédit magasinor ayant effectué un achat au cours des 6 derniers mois.

Pour comprendre le fonctionnement des 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

OutputTrue
True
True

Dans le premier cas,print((9 > 7) and (2 < 4)),9 > 7 et2 < 4 devaient être évalués à Vrai puisque l'opérateurand était utilisé.

Dans le second cas,print((8 == 8) or (6 != 6)), puisque8 == 8 évalué à True, cela n'a pas fait de différence que6 != 6 évalue à False car l'opérateuror a été utilisé. Si nous avions utilisé l'opérateurand, cela donnerait la valeur False.

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

Remplaçons les nombres entiers par un flotteur et visons les évaluations fausses:

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,

and doit avoir au moins une expression False évaluée à False,
or doit avoir les deux expressions évaluées à False,
not doit avoir son expression interne True pour que la nouvelle expression soit évaluée à False.

Si les résultats ci-dessus ne vous semblent pas clairs, nous passerons en revue quelquestruth tablesci-dessous pour vous mettre à jour.

Vous pouvez également écrire des instructions composées en utilisantand,or etnot:

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

Examinons d'abord l'expression la plus interne:(0.8 < 3.1) or (0.1 == 0.1). Cette expression est évaluée à True car les deux instructions mathématiques sont True.

Maintenant, nous pouvons prendre la valeur retournéeTrue et la combiner avec l'expression interne suivante:(-0.2 > 1.4) and (True). Cet exemple renvoieFalse car l'instruction mathématique-0.2 > 1.4 est False et(False) and (True) renvoie False.

Enfin, nous avons l'expression externe:not(False), qui prend la valeur True, donc la valeur finale renvoyée si nous imprimons cette instruction est:

OutputTrue

Les opérateurs logiquesand,or etnot évaluent les 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 en apprendre une partie pour améliorer notre pensée algorithmique lors de la programmation.

Vous trouverez ci-dessous des tables de vérité pour l'opérateur de comparaison== et chacun des opérateurs logiquesand,or etnot. Bien que vous puissiez les raisonner, il peut également être utile de les mémoriser, car cela peut accélérer le processus de prise de décision en matière de programmation.

== Table de vérité

x	==	y	Retour
True	==	True	True
True	==	Faux	Faux
Faux	==	True	Faux
Faux	==	Faux	True

Retour

True

Faux

True

Faux

True

Table de vérité

x	and	y	Retour
True	and	True	True
True	and	Faux	Faux
Faux	and	True	Faux
Faux	and	Faux	Faux

and

Retour

True

and

True

and

Faux

and

True

Faux

and

Faux

OU table de vérité

x	or	y	Retour
True	or	True	True
True	or	Faux	True
Faux	or	True	True
Faux	or	Faux	Faux

Retour

True

Faux

True

Faux

True

Faux

PAS la table de vérité

not	x	Retour
not	True	Faux
not	Faux	True

not

Retour

not

True

Faux

not

Faux

True

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

Utilisation d'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 uncondition suivi d'unclause.

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

Leclause est le bloc de code qui suit lescondition et dicte le résultat du programme. Autrement dit, il s'agit de la partiedo this de la construction "Six est Vrai, alors faites ceci."

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

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

else:
    print("Failing grade")

Ce programme évaluera si chaque élève a réussi ou échoué. Dans le cas d'un élève avec une note de 83, le premier énoncé sera évalué àTrue, et l'instruction d'impression dePassing grade sera déclenchée. Dans le cas d'un élève avec une note de 59, la première instruction sera évaluée àFalse, donc le programme passera à exécuter l'instruction d'impression liée à l'expressionelse:Failing grade .

Parce que chaque objet en Python peut être évalué à Vrai ou Faux, lePEP 8 Style Guide recommande de ne pas comparer une valeur àTrue ouFalse car il est moins lisible et renverra fréquemment un booléen inattendu. Autrement dit, vous devriezavoid en utilisantif sammy == True: dans vos programmes. À la place, comparezsammy à une autre valeur non booléenne qui renverra une valeur booléenne.

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

Conclusion

Ce tutoriel est passé en revue et comparé des opérateurs logiques appartenant au type booléen, ainsi que des tables de vérité et utilisant des booléens pour le contrôle de flux de programme.

Pour en savoir plus sur les autres types de données, consultez notre didacticiel «https://www.digitalocean.com/community/tutorials/understanding-data-types-in-python-3[Comprendre les types de données], ainsi que sur les instructions conditionnelles. dans notre didacticiel «https://www.digitalocean.com/community/tutorials/how-to-write-conditional-statements-in-python-3-2[Comment écrire des instructions conditionnelles].

TOC

Comprendre la logique booléenne en Python 3

introduction

Opérateurs de comparaison

Opérateurs logiques

Tables de vérité

== Table de vérité

Table de vérité

OU table de vérité

PAS la table de vérité

Utilisation d'opérateurs booléens pour le contrôle de flux

Conclusion

Related