pdf : diaporama #

Booléen #

Booléen #

En programmation, un booléen est un type de variable à deux états : vrai et faux.

Ils sont nommés ainsi d’après George Boole, fondateur de l’algèbre de Boole.

Booléen en Python #

En Python, les booléens sont True et False, ils sont du type bool

True
print(type(True))   # <class 'bool'>
False
print(type(False))  # <class 'bool'>

Comparaison #

Les opérateurs de comparaison courants sont identiques à ceux des mathématiques mais ATTENTION, il ne faut pas confondre l’égalité et l’affectation

variable = 5    # une affectation
5 == 8          # une égalité (qui est fausse)

Le résultat d’une comparaison est toujours un booléen

Comparaisons des nombres #

Appartenance à une structure #

On peut tester qu’un élément appartient à une structure avec le mot clé in

"a"     in "bonjour"        # False
"bon"   in "bonjour"        # True
1       in [2, 3, 4]        # False

Opérations sur les booléens #

Les opérateurs sur les booléens sont de deux types :

• opérateur unaire : prend un booléen et en renvoie un.
• opérateur binaire : prend deux booléens et en renvoie un.

Opérateur unaire : la négation #

C’est le seul opérateur unaire, il donne le contraire de ce qu’on lui passe.

En français l’opérateur de négation est noté NON. En Python, l’opérateur de négation est not.

not True    # s'évalue à False
not False   # s'évalue à True

Table de vérité avec True et False #

Table de vérité avec des bits #

Les tables de vérité sont abregées en notant :

• 1 pour True
• 0 pour False

Opérateur binaire : le OU, noté or #

Il est vrai si l’un des deux booléens est vrai.

False or False  # False
False or True   # True
True  or False   # True
True  or True    # True

Opérateur binaire : le ET, noté and #

Il est vrai si les deux booléens sont vrais.

False and False  # False
False and True   # False
True  and False   # False
True  and True    # True

Opérateur binaire : le XOR noté ^ #

Il est vrai si EXACTEMENT un des deux booléens est vrai

False ^ False  # False
False ^ True   # True
True  ^ False   # True
True  ^ True    # False

Python et les booléens #

Python permet de comparer n’importe quoi à un booleen.

Par exemple, une chaîne de caractère vide est évaluée à fausse.

bool(1)             # True
bool(0)             # False
bool("")            # False
bool("abc")         # True
bool([])            # False
bool([1, 2])        # True

• 0 est faux, les autres entiers sont vrais,
• une structure vide est fausse, les autres sont vraies.

Complément : None et l’identité is #

Python propose la valeur None (rien) qui est fréquement utilisé pour représenter l’absence d’une valeur.

Étant le seul objet du type NoneType, on peut tester son identité avec is :

1     is None   # False
"abc" is None   # False
None  is None   # True
a = 5
a is None       # False

On verra plus tard qu’une fonction qui ne se termine par return ... renvoie néanmoins None.

Table de vérité plus complexe #

On peut chaîner les opérations booléennes pour construire une expression booléenne.

Une colonne par valeur et une colonne pour l’expression :

Propriétés mathématiques de l’algèbre de Boole #

Il existe de nombreuses notations utilisées pour décrire l’algèbre de Boole, nous utiliserons les notations de Python.

Définition #

On considère l’ensemble {0, 1} ou {False, True} muni de trois opérations :

la négation not, le et logique and, le ou logique or.

Elles sont définies par les tables de vérité présentées plus haut.

Complémentarité #

• not(not(a)) = a
• a or (not a) = 1
• a and (not a) = 0

Associativité #

• a or (b or c) = (a or b) or c
• a and (b and c) = (a and b) and c

Distributivité #

• a or (b and c) = (a and b) or (a and c)
• a and (b or c) = (a or b) and (a or c)

Ainsi, on retrouve les propriétés des opérations sur les nombres. Pour simplifier, or se comporte comme une somme et and comme un produit.

Autres tables de vérité #

Toutes les opérations binaires peuvent être définies à l’aide des trois opérateurs présentés plus haut.

Par exemple : a xor b = (a and not b) or (not a and b)

Pour le vérifier, on construit les tables de vérité de chaque membre et on les compare.

a xor b = (a and not b) or (not a and b) #