Name: Tremplin Numérique
Price range: $$$

La logique booléenne est une partie essentielle des mathématiques, de l'ingénierie et de la programmation. Dans la plupart des langues, il existe un type de données booléen dédié. Lorsque vous êtes nouveau à Python, les booléens peuvent vous confondre en raison de la façon dont ils fonctionnent spécifiquement dans cette langue. Nous explorerons les tenants et aboutissants de la logique booléenne à Python.

Sommaire

Comprendre les bases de la logique booléenne

La logique booléenne est le fondement de la prise de décision dans la programmation. À la base, il se résume à une question simple. Est-ce que quelque chose de vrai ou de faux?

Le concept provient du mathématicien George Boole, qui, au 19e siècle, a développé un système algébrique de logique en utilisant seulement deux valeurs: vrai et faux. En informatique, cette façon de penser binaire se traduit parfaitement dans le monde numérique. En effet, les ordinateurs fonctionnent finalement avec deux états: sur (1) et hors (0).

Ce ne sont pas seulement les ordinateurs. Il existe de nombreuses analogies du monde réel qui suivent ce concept. Une ampoule peut être allumée ou éteinte. Une porte peut être verrouillée ou déverrouillée. Lorsque vous vérifiez la météo, il peut être ensoleillé ou non ensoleillé. Ce sont tous des exemples de résultats booléens.

En programmation, la logique booléenne est ce qui permet aux ordinateurs de «prendre des décisions». Chaque fois qu'un programme doit vérifier quelque chose, qu'il s'agisse de valider un mot de passe, de contrôler les mécanismes de jeu ou de déterminer si un paiement en ligne est passé, il s'appuie sur la logique booléenne. Sans cela, les ordinateurs ne feraient que traiter les données aveuglément. Avec lui, ils peuvent réagir, se ramifier et s'adapter à différentes situations.

Valeurs booléennes en python

Maintenant que vous avez vu le concept de logique booléenne, voyons comment il apparaît dans Python. Dans Python, les valeurs booléennes sont représentées par deux mots clés spéciaux:

True
False

Remarquez les majuscules en deux mots. C'est important parce que l'écriture true ou false En minuscules provoquera une erreur Python, car Python les traite comme des variables non définies. Les deux True et False appartiennent à Python intégré bool Type de données:

print(type(True))
print(type(False))

Un fait amusant est que bool est en fait une sous-classe de int. Cela signifie que les booléens se comportent comme les chiffres 1 et 0 Dans certaines situations:

print(True == 1)
print(False == 0)
print(True + True)
print(False + 5)

Cela peut être utile dans certains cas, mais cela peut également conduire à la confusion si vous ne vous y attendez pas. Ainsi, bien que Python autorise ce comportement, il est préférable de considérer les booléens comme des valeurs logiques, pas des nombres.

Python fournit le bool() fonction, qui convertit toute valeur en booléen. C'est là que le concept de valeurs de « vérité » et de « fausse » entre en jeu. Les valeurs de faussesse sont traitées comme False. Celles-ci incluent

0
0.0
"" (chaîne vide)
() (liste vide)
{} (Dictionnaire vide)
None

Tout le reste est considéré comme la vérité (et évalue True.)

print(bool(0))
print(bool(""))
print(bool(()))print(bool(42))
print(bool("hi"))
print(bool((1, 2)))

Opérateurs logiques à Python

Jusqu'à présent, nous avons vu que Python a deux valeurs booléennes: True et False. Mais comment les utilisons-nous en pratique? C'est là que les opérateurs logiques entrent en jeu. Ces types d'opérateurs nous permettent de comparer les valeurs, de vérifier les relations et de poser des questions oui-non.

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs. Le résultat d'une comparaison est toujours une valeur booléenne (True ou False.) Voici la liste complète des opérateurs de comparaison de Python:

Opérateur	Signification
==	Égal à
! =	Pas égal à
>	Supérieur à
<	Moins que
> =	Supérieur ou égal à
<=	Moins ou égal à

Voyons quelques exemples de ce qu'ils font.

print(10 > 3)
print(10 < 3)
print(5 == 5)
print(5 != 5)
print(8 >= 8)
print(2 <= 1)

Les opérateurs de comparaison fonctionnent non seulement avec les nombres mais aussi avec les chaînes et autres types de données:

print("apple" == "apple")
print("apple" != "banana")
print("cat" < "dog")

Opérateurs d'identité

Alors que les opérateurs de comparaison vérifient si deux valeurs sont égales, les opérateurs d'identité vérifient si deux variables se réfèrent réellement au même objet en mémoire. Python fournit deux opérateurs d'identité:

Opérateur	Signification
`is`	Rendements `True` Si les deux variables pointent vers le même objet
`is not`	Rendements `True` S'ils pointent vers différents objets

Un exemple rapide:

a = (1, 2, 3)
b = a
c = (1, 2, 3)print(a == b)
print(a is b)
print(a is c)

Ici, a et b ne sont pas seulement égaux. Ils sont littéralement la même liste en mémoire. D'autre part, a et c Peut avoir le même contenu, mais ce sont deux objets distincts. C'est pourquoi le résultat est False.

Opérateurs d'adhésion

Les opérateurs d'adhésion sont utilisés pour vérifier si une valeur existe dans une séquence ou une collection. Ils reviennent True Si l'article est trouvé, et False Si ce n'est pas le cas. Ils rendent votre code plus lisible et expressif. Au lieu d'écrire des boucles ou des vérifications complexes, vous pouvez les utiliser pour vérifier si quelque chose est membre d'une collection.

Opérateur	Signification
`in`	Rendements `True` Si la valeur est présente dans la séquence
`not in`	Rendements `True` Si la valeur est pas présent

Voyons quelques exemples de type de chaîne.

print("a" in "apple")
print("app" in "apple")
print("z" not in "apple")

Ici, in vérifie les sous-chaînes ainsi que les caractères uniques. Quant aux séquences:

numbers = (1, 2, 3, 4, 5)print(3 in numbers)
print(10 in numbers)
print(10 not in numbers)

Nous vérifions si un certain élément existe dans la séquence, dans ce cas, une liste Python.

Logique booléenne dans les conditions et les boucles

Cependant, les booléens ne sont pas seulement des valeurs abstraites. Dans de nombreux programmes, ils contrôleront votre flux de code et votre prise de décision. Chaque fois que votre programme doit choisir un chemin ou répéter une action, il s'appuie sur la logique booléenne. Il y a deux endroits principaux que vous verrez en action:

Conditionnels (if / elif / else)
Boucle (pendant et pour)

Explorons chacun.

Conditionnels

Les conditionnels permettent à votre programme de réagir différemment selon la question de savoir si une condition est True ou False. Voici une vérification conditionnelle simple:

        age = 20if age >= 18:
   print("You are allowed to vote.")

Python évalue age >= 18. Si le résultat est Truele bloc en retrait des courses. Si c'est Falsele bloc est sauté. Ici, depuis 20 >= 18 est Truele message est imprimé. Voici un autre exemple où nous exécutons une autre instruction de code dans le cas de False.

        password = "password123"if password == "password123":
    print("Access granted.")
else:
    print("Access denied.")

Si la condition est Truele premier bloc fonctionne. Sinon, le else Block s'exécute à la place. S'il y a plus d'une condition, alors nous utilisons elif instructions.

        score = 85if score >= 90:
   print("Grade: A")
elif score >= 80:
   print("Grade: B")
elif score >= 70:
   print("Grade: C")
else:
   print("Grade: F")

Python vérifie chaque condition dans l'ordre. Dès qu'une condition est Trueson bloc fonctionne et le reste est sauté. C'est ainsi que les booléens aident les programmes à se ramifier dans différentes possibilités.

Boucles

Les boucles utilisent la logique booléenne pour déterminer s'ils devraient continuer à fonctionner. Il est particulièrement utile dans les boucles.

        count = 0while count < 3:
    print("Counting:", count)
    count += 1

Chèques Python count < 3. Si c'est Truele corps de la boucle fonctionne. Après avoir fonctionné, Python vérifie à nouveau la condition. Quand ça devient Falsela boucle s'arrête. Vous pouvez également utiliser la valeur booléenne True Pour initier une boucle infinie.

        while True:
   command = input("Type 'exit' to quit: ")
   if command == "exit":
       break

Ici, la condition True fait fonctionner la boucle pour toujours, mais la logique booléenne à l'intérieur de la boucle (command == "exit") nous permet d'éclater en cas de besoin. Boolean Logic joue également un rôle dans for boucles. Cela peut ne pas avoir l'air si apparent, mais ils sont là.

        numbers = (1, 2, 3, 4, 5)for num in numbers:
   if num % 2 == 0:
       print(num, "is even")
   else:
       print(num, "is odd")

Dans chaque itération, Python demande essentiellement s'il reste un autre élément dans la liste. Si oui, affectez-le à NUM et exécutez le corps de la boucle. Si non, alors arrêtez la boucle. Cette question cachée oui / non est la logique booléenne en action.

Les conditions et les boucles sont l'épine dorsale de la logique de programmation. Sans booléens, votre code fonctionnerait de haut en bas, de la même manière à chaque fois. Avec eux, vos programmes peuvent prendre des décisions en fonction des données et répéter des actions.

Erreurs courantes pour éviter

La logique booléenne à Python est simple une fois que vous avez compris, mais il y a quelques pièges que les débutants (et parfois même les développeurs expérimentés) rencontrent.

Déroutant `is` avec `==`

Le == Le signe vérifie si deux valeurs sont égales. Alors que is Vérifie si deux variables se réfèrent au même objet en mémoire. Utiliser == Lorsque vous vous souciez de l'égalité des valeurs. Utiliser is uniquement lors de la vérification de l'identité des objets

Supposant `bool()` La conversion est intuitive

Le bool() La fonction convertit les valeurs en True ou False en fonction de savoir s'ils sont la vraie ou la fausseté. Les débutants supposent souvent que l'écriture bool("False") donnera False. Dans Python, toute chaîne non vide est la vérité, peu importe ce qu'elle dit. Seulement "" (une chaîne vide) évalue à False.

Oublier la priorité de l'opérateur

Les opérateurs booléens n'évaluent pas toujours de gauche à droite. Par exemple:

a = 5
print(not a == 5)

À première vue, cela semble que cela signifie not (a == 5) (qui est False), mais ce que cela signifie vraiment c'est (not a) == 5. Depuis not a devient Falsetu compames False == 5. C'est pourquoi vous devez toujours utiliser des parenthèses lorsque vous mélangez des opérateurs booléens avec des comparaisons.

print(not (a == 5))

À présent, vous devriez avoir une bonne compréhension de la façon d'utiliser la logique booléenne dans Python. Vous pouvez maintenant éviter les erreurs tout en apprenant Python. N'oubliez pas de créer des projets pour solidifier votre apprentissage.