Commencer avec la logique booléenne en Python

La logique booléenne est une partie essentielle des mathématiques, de l'ingénierie et de la programmation. Dans la plupart des langages, il existe un type de données booléen dédié. Lorsque vous débutez en Python, les booléens peuvent vous sembler déroutants en raison de leur fonctionnement spécifique dans ce langage. Nous explorerons les tenants et aboutissants de la logique booléenne en Python.

Comprendre les bases de la logique booléenne

La logique booléenne est le fondement de la prise de décision en programmation. En son cœur, tout se résume à une question simple : quelque chose est-il vrai ou faux ?

Le concept vient du mathématicien George Boole, qui, au XIXe siècle, a développé un système algébrique de logique utilisant seulement deux valeurs : vrai et faux. En informatique, cette manière de penser en binaire se traduit parfaitement dans le monde numérique. Cela s'explique par le fait que les ordinateurs fonctionnent finalement avec deux états : allumé (1) et éteint (0).

Il ne s'agit pas seulement des ordinateurs. Il existe de nombreuses analogies dans le 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. En consultant la météo, il peut faire ensoleillé ou non. 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, que ce soit pour valider un mot de passe, contrôler les mécanismes d'un jeu ou déterminer si un paiement en ligne a été effectué, il s'appuie sur la logique booléenne. Sans elle, les ordinateurs ne feraient que traiter les données aveuglément. Avec elle, 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 la logique booléenne, voyons comment cela apparaît en Python. En Python, les valeurs booléennes sont représentées par deux mots-clés spéciaux :

True
False

Remarquez les lettres majuscules dans les deux mots. C'est important car écrire true ou false en minuscules provoquera une erreur en Python, car Python les considère comme des variables non définies. Les deux True et False appartiennent au type de données intégré bool de Python :

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

Un fait amusant est que bool est en réalité une sous-classe de int. Cela signifie que les booléens se comportent comme les nombres 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 aussi entraîner de la confusion si vous ne vous y attendez pas. Ainsi, bien que Python permette ce comportement, il est préférable de considérer les booléens comme des valeurs logiques, et non comme des nombres.

Python fournit la fonction bool(), qui convertit n'importe quelle valeur en un booléen. C'est là que le concept de valeurs « truthy » et « falsy » entre en jeu. Les valeurs falsy sont considérées comme False. Celles-ci incluent

• 0
• 0,0
• "" (chaîne vide)
• [] (liste vide)
• {} (dictionnaire vide)
• Aucun

Tout le reste est considéré comme vrai (et évalue à True.)

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

Opérateurs logiques en Python

Jusqu'à présent, nous avons vu que Python possède deux valeurs booléennes : True et False. Mais comment les utilisons-nous réellement en pratique ? C'est là que les opérateurs logiques entrent en jeu. Ce type d'opérateurs nous permet de comparer des valeurs, de vérifier des relations et de poser des questions de type 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 en Python :

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 des nombres mais aussi avec des chaînes de caractères et d'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 font réellement référence au même objet en mémoire. Python fournit deux opérateurs d'identité :

is

is not

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. En revanche, a et c peuvent avoir le même contenu, mais ce sont deux objets distincts. C'est pourquoi le résultat est False.

Opérateurs d'appartenance

Les opérateurs d'appartenance sont utilisés pour vérifier si une valeur existe dans une séquence ou une collection. Ils renvoient True si l'élément est trouvé, et False s'il ne l'est pas. 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 fait partie d'une collection.

in

not in

Voyons quelques exemples de type 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 individuels. En ce qui concerne les 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 conditionnelles et les boucles

Les booléens ne sont pas juste des valeurs abstraites. Dans de nombreux programmes, ils contrôlent le flux du code et la 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 principaux endroits où vous verrez cela en action :

1. Conditionnels (if/elif/else)
2. Boucles (while et for)

Explorons chacun.

Conditionnels

Les instructions conditionnelles permettent à votre programme de réagir différemment selon que la condition est True ou False. Voici un exemple simple de vérification conditionnelle :

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

Python évalue age >= 18. Si le résultat est True, le bloc indenté s'exécute. Si c’est False, le bloc est ignoré. Ici, puisque 20 >= 18 est True, le message est affiché. Voici un autre exemple où nous exécutons une autre instruction de code en cas de False.

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

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

score = 85
if 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 True, son bloc s'exécute et les autres sont ignorés. C'est ainsi que les booléens aident les programmes à se ramifier en différentes possibilités.

Boucles

Les boucles utilisent la logique booléenne pour déterminer si elles doivent continuer à s'exécuter. C'est particulièrement utile dans les boucles while.

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

Python vérifie count < 3. Si c’est True, le corps de la boucle s’exécute. Après l’exécution, Python vérifie à nouveau la condition. Quand elle devient False, la boucle s’arrête. Vous pouvez également utiliser la valeur booléenne True pour lancer une boucle infinie.

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

Ici, la condition True fait que la boucle s'exécute indéfiniment, mais la logique booléenne à l'intérieur de la boucle (command == "exit") nous permet d'en sortir lorsque nécessaire. La logique booléenne joue également un rôle dans les boucles for. Cela peut ne pas sembler évident, mais elle est bien là.

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

À chaque itération, Python se demande essentiellement s'il reste un autre élément dans la liste. Si oui, il l'affecte à num et exécute le corps de la boucle. Si non, la boucle s'arrête. Cette question cachée de oui/non est la logique booléenne en action.

Les conditionnels et les boucles sont la colonne vertébrale de la logique de programmation. Sans les booléens, votre code s'exécuterait simplement de haut en bas, de la même manière à chaque fois. Avec eux, vos programmes peuvent prendre des décisions basées sur les données et répéter des actions.

Erreurs courantes à éviter

La logique booléenne en Python est simple une fois que vous en avez compris le principe, mais il existe quelques pièges auxquels les débutants (et parfois même les développeurs expérimentés) se heurtent.

Confondre is avec ==

Le signe == vérifie si deux valeurs sont égales. Tandis que is vérifie si deux variables font référence au même objet en mémoire. Utilisez == lorsque vous vous souciez de l'égalité des valeurs. Utilisez is uniquement pour vérifier l'identité de l'objet.

En supposant que la conversion bool() soit intuitive

La fonction bool() convertit les valeurs en True ou False en fonction de leur véracité. Les débutants supposent souvent que écrire bool("False") donnera False. En Python, toute chaîne non vide est considérée comme vraie, peu importe ce qu’elle contient. Seule la chaîne "" (une chaîne vide) est évaluée à False.

Oublier la priorité des opérateurs

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

a = 5
print(not a == 5)

À première vue, cela semble signifier not (a == 5) (ce qui est False), mais ce que cela signifie en réalité est (not a) == 5. Comme not a devient False, vous comparez False == 5. C'est pourquoi vous devriez toujours utiliser des parenthèses lorsque vous mélangez les opérateurs booléens avec les comparaisons.

print(not (a == 5))

À présent, vous devriez bien comprendre comment utiliser la logique booléenne en Python. Vous pouvez désormais éviter les erreurs lors de l'apprentissage de Python. N'oubliez pas de réaliser des projets pour consolider votre apprentissage.