Les booléens (`True`, `False`) et opérateurs logiques (`and`, `or`, `not`)

Les booléens : les piliers de la logique en Python

Au coeur de toute prise de décision dans un programme informatique se trouvent les valeurs booléennes. En Python, comme dans la plupart des langages de programmation, un booléen est un type de données qui ne peut avoir que l'une des deux valeurs : `True` (vrai) ou `False` (faux). Ces valeurs sont fondamentales pour contrôler le flux d'exécution d'un programme, notamment dans les structures conditionnelles (comme les instructions `if`) et les boucles (`while`).

Il est crucial de noter qu'en Python, `True` et `False` sont des mots-clés et doivent être écrits avec une majuscule initiale. Tenter de les écrire en minuscules (`true` ou `false`) résultera en une erreur `NameError` car Python les interprétera comme des noms de variables non définies.

condition_verifiee = True
acces_refuse = False

print(type(condition_verifiee))  # Affichera : 
print(acces_refuse)              # Affichera : False

Les valeurs booléennes sont le plus souvent le résultat d'expressions de comparaison. Python offre une gamme complète d'opérateurs de comparaison qui évaluent à `True` ou `False` :

• `==` : Egal à
• `!=` : Différent de
• `<` : Strictement inférieur à
• `>` : Strictement supérieur à
• `<=` : Inférieur ou égal à
• `>=` : Supérieur ou égal à

resultat1 = (5 == 5)  # resultat1 vaudra True
resultat2 = (10 < 3)  # resultat2 vaudra False
resultat3 = ("python" != "Java") # resultat3 vaudra True

L'opérateur logique `and` : la conjonction

L'opérateur logique `and` est utilisé pour combiner deux expressions booléennes. Il évalue à `True` si et seulement si les deux expressions qu'il relie sont `True`. Si l'une ou l'autre (ou les deux) est `False`, le résultat de l'opération `and` sera `False`. C'est l'équivalent du "ET" logique en mathématiques ou en logique formelle.

Voici la table de vérité pour l'opérateur `and` :

• `True and True` ⇒ `True`
• `True and False` ⇒ `False`
• `False and True` ⇒ `False`
• `False and False`⇒ `False`

En pratique, cela permet de vérifier plusieurs conditions simultanément :

age = 25
possede_permis = True

peut_conduire_voiture = (age >= 18) and possede_permis
# (True and True) -> peut_conduire_voiture vaudra True

utilisateur_actif = True
compte_valide = False
peut_se_connecter = utilisateur_actif and compte_valide
# (True and False) -> peut_se_connecter vaudra False

L'opérateur logique `or` : la disjonction

L'opérateur logique `or` est également utilisé pour combiner deux expressions booléennes. Il évalue à `True` si au moins l'une des deux expressions qu'il relie est `True`. Le résultat de l'opération `or` ne sera `False` que si les deux expressions sont `False`. C'est l'équivalent du "OU inclusif" logique.

Voici la table de vérité pour l'opérateur `or` :

• `True or True` ⇒ `True`
• `True or False` ⇒ `True`
• `False or True` ⇒ `True`
• `False or False` ⇒ `False`

Cet opérateur est utile lorsque plusieurs conditions alternatives peuvent satisfaire un critère :

est_weekend = True
est_jour_ferie = False

peut_se_reposer = est_weekend or est_jour_ferie
# (True or False) -> peut_se_reposer vaudra True

coupon_valide = False
reduction_speciale = False
a_droit_reduction = coupon_valide or reduction_speciale
# (False or False) -> a_droit_reduction vaudra False

L'opérateur logique `not` : la négation

L'opérateur logique `not` est un opérateur unaire, ce qui signifie qu'il agit sur une seule expression booléenne. Son rôle est d'inverser la valeur de vérité de cette expression. Si une expression est `True`, l'application de `not` la rendra `False`, et vice-versa.

Voici la table de vérité pour l'opérateur `not` :

• `not True` ⇒ `False`
• `not False` ⇒ `True`

Cet opérateur est souvent utilisé pour vérifier l'absence d'une condition ou pour rendre des conditions plus lisibles :

porte_fermee = True
porte_ouverte = not porte_fermee
# porte_ouverte vaudra False

erreur_detectee = False
systeme_ok = not erreur_detectee
# systeme_ok vaudra True

# Exemple dans une condition if
if not porte_ouverte:
    print("La porte n'est pas ouverte, elle est donc fermée.")