Programmation Python/Booléens
Définition.
Un est un type de données qui ne peut prendre que deux valeurs : vrai ou faux. En Python, les constantes littérales sont notées "True" et "False".
Tous les types de variables peuvent être interprétés de manière booléenne. Par exemple, pour les entiers (int), la valeur "0" correspond à "faux" et les autres valeurs à "vrai". Il en est de même pour tous les autres types : une valeur particulière vaut "False" et le reste des valeurs "True". Le tableau suivant présente les valeurs "faux" pour les principaux type de données.
Exemple d'expressions booléennes.
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
Affiche :
 1 True
 2 False
 3 True
 4 False
 5 True
 6 True
 7 False
 8 True
 9 False
Que se passe-t-il ? Le programme consiste en un tas de codice_1. Chaque codice_1 affiche un nombre et une expression. Le nombre sert à savoir de quel ligne on parle. Notez bien comme chaque expression finit soit par codice_3 ou codice_4. En python False et True peuvent aussi être écrits 0 et 1.
And.
Voyez ce code :
print(1, a == 6)
print(2, a == 7)
Cela affiche respectivement a codice_4 et a codice_3 comme attendu, le premier est vrai, et le second est faux. La troisième ligne, codice_7, est un peu différente. L'opérateur codice_8 signifie que si les deux expressions qui l'entourent sont vraies alors toute l'expression l'est également, autrement elle est fausse. Le comportement de codice_8 peut être résumé comme suit :
Notez que si la première expression est fausse Python ne vérifie pas la seconde car il sait que l'expression car il sait que tout l'expression est fausse. Essayez de lancer codice_10 et comparez le à codice_11. Le terme technique pour ceci est "short-circuit evaluation" (littéralement "évaluation en circuit court").
Not.
La ligne suivante, codice_12, utilise l'opérateur codice_13. codice_13 retourne l'opposé d'une expression (l'expression pourrait être réécrite codice_15). Voici la table de vérité :
Or.
Les deux lignes suivantes, codice_16 et codice_17 utilisent l'opérateur codice_18. codice_18 retourne vrai si la première expression est vraie ou si la seconde expression est vraie, si la seconde expression est vraie ou si les deux le sont. Si aucune n'est vraie il retourne faux. Voici sa table de vérité :
Notez que si la première expression est vraie Python ne vérifie pas la seconde expression car il sait que toute l'expression est vraie. Cela marche car codice_18 est vrai si au moins une des expressions est vraie. La première partie est vraie donc la seconde pourrait être vraie ou fausse, mais l'expression est toujours vraie.
Les deux lignes suivantes, codice_21 et codice_22, montrent que les parenthèses peuvent être utilisées pour regrouper des expressions et forcer l’évaluation d'une partie en premier. Notez que les parenthèses ont changé l'expression de "faux" à "vrai". La raison est que les parenthèses ont forcé le codice_13 à s'appliquer à toute l'expression au lieu de seulement la partie codice_24.
bool().
La valeur booléenne d'une variable "x" peut être obtenue avec codice_25. Voici la table de vérité selon le type de la variable :
Pour tester si une variable "x" n'est pas nulle, on utilise : codice_26.
Note sur les opérateurs booléens.
Exemple :
 »> 'a' == ('a' or 'b') # 'a' = True, donc ('a' or 'b') = 'a' sans avoir à évaluer 'b'. Ce qui revient à : 'a' == 'a'
 True
 »> 'b' == ('a' or 'b') # Revient à : 'b' == 'a', de la même manière
 False 
 »> 'a' == ('a' and 'b') # 'a' = True et 'b' = True, donc ('a' and 'b') = 'b' (dernière expression évaluée). Ce qui revient à : 'a' == 'b'
 False
 »> 'b' == ('a' and 'b') # Revient à : 'b' == 'b', de la même manière
 True 
Véracité/fausseté d'une expression.
Lorsqu'un programme contient des instructions telles que codice_27 ou codice_28, l'ordinateur qui exécute ce programme doit évaluer la véracité d'une condition, c'est-à-dire déterminer si une expression est vraie ou fausse. Par exemple, une boucle initiée par codice_29: s'exécutera aussi longtemps que la condition codice_30 restera vraie.
Mais comment un ordinateur peut-il déterminer si quelque chose est vrai ou faux ?
En fait - et vous le savez déjà - un ordinateur ne manipule strictement que des nombres. Tout ce qu'un ordinateur doit traiter doit d'abord toujours être converti en valeur numérique. Cela s'applique aussi à la notion de vrai/faux. En Python, tout comme en C, en Basic et en de nombreux autres langages de programmation, on considère que toute valeur numérique autre que zéro est « vraie ». Seule la valeur zéro est « fausse ». Exemple :
a = input('Entrez une valeur quelconque')
if a:
 print("vrai")
else:
 print("faux")
Le petit script ci-dessus n'affiche « faux » que si vous entrez la valeur 0. Pour toute autre valeur numérique, vous obtiendrez « vrai ».
Si vous entrez une chaîne de caractères ou une liste, vous obtiendrez encore « vrai ». Seules les chaînes ou les listes "vides" seront considérées comme « fausses ».
Tout ce qui précède signifie donc qu'une expression à évaluer, telle par exemple la condition a > 5 , est d'abord convertie par l'ordinateur en une valeur numérique. (Généralement 1 si l'expression est vraie, et zéro si l'expression est fausse). Exemple :
a = input('entrez une valeur numérique : ')
b = (a < 5)
print ('la valeur de b est', b, ':')
if b:
 print("la condition b est vraie")
else:
 print("la condition b est fausse")
Le script ci-dessus vous renvoie une valeur codice_31 (condition vraie) si vous avez entré un nombre plus petit que 5.
Ces explications ne sont qu'une première information à propos d'un système de représentation des opérations logiques de l’"algèbre de Boole".
Exemple.
Créer le fichier "password1.py" :
name = input("What is your name? ")
password = input("What is the password? ")
if name == "Josh" and password == "Friday":
 print("Welcome Josh")
elif name == "Fred" and password == "Rock":
 print("Welcome Fred")
else:
 print("I don't know you.")
Resultats :
Écrire un programme devine votre nom, avec seulement trois chances avant de terminer.
print("Try to guess my name!")
count = 1
name = "guilherme"
guess = input("What is my name? ")
while count < 3 and guess.lower() != name: # .lower permet ici d'ignorer les majuscules dans le nom
 print("You are wrong!")
 guess = input("What is my name?")
 count = count + 1
if guess.lower() != name:
 print("You are wrong!")
 print("You ran out of chances.")
else:
 print("Yes! My name is"), name + "!"