Travail avec le type booléen

5.1 Type bool

En Python, il y a un type de données booléen spécial qui permet de vérifier la véracité des conditions et expressions. Il est désigné par le mot-clé bool (bien que généralement appelé Boolean) et est utilisé pour représenter l'une des deux valeurs : True (Vrai) ou False (Faux).

Ce type de données est extrêmement utile en programmation pour contrôler l'ordre d'exécution du programme à l'aide des opérateurs conditionnels, tels que if, else et elif, ainsi que pour contrôler les boucles et autres structures de contrôle.

Note importante

Le type de données booléen en Python est représenté par deux objets constants : True et False. Cependant, il faut noter que Python considère True comme la valeur numérique 1 et False comme 0. Cela permet de les utiliser dans des opérations arithmétiques et rend le type bool une sous-classe du type int.

Application pratique

Malgré les deux valeurs possibles, le type bool est puissant non pas à cause de ses valeurs, mais grâce à l'ensemble d'opérations logiques que l'on peut effectuer dessus. Nous en parlerons ci-dessous.

5.2 Opérateurs logiques

Les opérations logiques en Python jouent un rôle important dans le contrôle de l'ordre d'exécution du programme et la prise de décisions. Les principales opérations logiques incluent and, or et not. Comprendre leur application peut grandement améliorer l'efficacité de votre code.

ET logique (AND)

L'opérateur and retourne True seulement si ses deux arguments sont vrais (True). Cet opérateur est souvent utilisé pour vérifier la véracité de plusieurs conditions simultanément.

a = True
b = False
print(a and b)  # Affichera: False 

OU logique (OR)

L'opérateur or retourne True, si au moins un de ses arguments est vrai. C'est utile pour les conditions où l'exécution du code doit se poursuivre si au moins une des plusieurs conditions possibles est remplie.

a = True
b = False
print(a or b)  # Affichera: True

NON logique (NOT)

L'opérateur not inverse la valeur booléenne de son argument. Si l'argument est True, le résultat sera False et vice-versa. Cela peut être utile pour créer des conditions de refus.

a = True
print(not a)  # Affichera: False

Utilisation avancée

Les opérateurs logiques sont souvent utilisés en combinaison pour créer des expressions conditionnelles complexes qui aident à contrôler des flux d'exécution plus complexes.

a = 5
b = 10
c = 20
result = a < b and b < c  # Vérifie que a est inférieur à b et b est inférieur à c
print(result)  # Affichera: True

Les opérations logiques en Python fournissent un outil puissant pour contrôler le comportement du programme basé sur différentes conditions. Elles simplifient non seulement l'écriture du code, mais le rendent également plus lisible et maintenable.

5.3 Exemples pratiques

Python permet de convertir d'autres types de données en type booléen avec la fonction bool(). Par défaut, toute valeur non nulle ou non vide sera convertie en True, et les valeurs nulles ou vides en False.

Exemples de conversion de types :

print(bool(0))  # Affichera False 
print(bool(42))  # Affichera True
print(bool(""))  # Affichera False
print(bool("Text"))  # Affichera True

Utilisation des variables logiques dans les conditions :

a = 5
b = 10
c = 20
is_a_min = a < b and a < c  # Vérifie que a est inférieur à b et a est inférieur à c 
print(is_a_min)  # Affichera: True

Il n'est pas nécessaire de comparer la variable logique avec True ou False, car le résultat de la comparaison est déjà True ou False. Exemple :

if a < b:
    print("a is min")

                    is_a_less = a < b
                    if is_a_less == True:
                        print("a is min")              
                

                    is_a_less = a < b
                    if is_a_less:
                        print("a is min")               
                

Le résultat de toute comparaison a la valeur True ou False, donc il peut être assigné à une variable – comme cela a été fait dans l'exemple ci-dessus. Mais dans la condition if, ou la boucle while, il n'est pas nécessaire de comparer la variable logique avec True. La variable logique contient déjà la bonne valeur. Donnez-lui juste un bon nom, et tout se mettra en place.

En d'autres termes, au lieu d'écrire «if a == True:» il suffit d'écrire «if a:». Et au lieu d'écrire «if a == False:» écrire «if not a:».