fiche mémo : 2.3. Booléens et conditionnels.

Utiliser des booléens pour les branchements conditionnels

Vincent GODARD - V1 - 27/02/2025

Cours Introduction à la programmation

Département de géographie - L3 - Université de Paris 8

Traduction librement (largement) inspirée de : https://www.kaggle.com/code/colinmorris/booleans-and-conditionals

Sources :

Kaggle : https://www.kaggle.com/learn

Python Tutorial : https://www.w3schools.com/python/default.asp

Cours de Python : https://python.sdv.u-paris.fr/00_avant_propos/

Téléchargement des documents nécessaires :

Dossier compressé à télécharger => (pas utile ici).

1. Booléens¶

Python possède un type de variable appelé bool. Il a deux valeurs possibles : True et False.

x = True
print(x)
print(type(x))

Plutôt que de mettre True ou False directement dans notre code, nous obtenons généralement des valeurs booléennes à partir d'opérateurs booléens. Il s'agit d'opérateurs qui répondent aux questions par oui/non. Nous allons passer en revue certains de ces opérateurs ci-dessous.

2. Opérations de comparaison

Opération	Description	Opération	Description
a == b	a égal à b	a != b	a différent de b
a < b	a inférieur à b	a > b	a supérieur à b
a <= b	a inférieur ou égal à b	a >= b	a supérieur ou égal à b

def can_run_for_president(age): # traduction : peut se présenter à la présidence
    """Une personne de l'âge donné peut-elle se présenter à la présidence aux États-Unis ?"""
# La Constitution américaine stipule que vous devez avoir au moins 35 ans
    return age >= 35

print("Une personne de 19 ans peut-elle se présenter à la présidence ?", can_run_for_president(19))
print("Une personne de 45 ans peut-elle se présenter à la présidence ?", can_run_for_president(45))

## Les comparaisons fonctionnent souvent comme on l’espère
3.0 == 3

## Mais parfois, elles peuvent être délicates
'3' == 3

Les opérateurs de comparaison peuvent être combinés avec les opérateurs arithmétiques que nous avons déjà vus pour exprimer une gamme pratiquement illimitée de tests mathématiques. Par exemple, nous pouvons vérifier si un nombre est impair (odd) en vérifiant que le module avec 2 renvoie 1 :

def is_odd(n): # est impair
    return (n % 2) == 1

print("Is 100 odd?", is_odd(100))
print("Is -1 odd?", is_odd(-1))

N'oubliez pas d'utiliser == au lieu de = lorsque vous faites des comparaisons. Si vous écrivez n == 2, vous vous interrogez sur la valeur de n. Lorsque vous écrivez n = 2, vous modifiez la valeur de n.

3. Combinaison de valeurs booléennes

Vous pouvez combiner des valeurs booléennes en utilisant les concepts standards « and », « or » et « not ». En fait, les mots pour le faire sont : and, or et not ("not True", "not False").

Avec ceux-ci, nous pouvons rendre notre fonction can_run_for_president plus précise.

def can_run_for_president(age, is_natural_born_citizen):
    """Une personne de l'âge et du statut de citoyenneté donnés peut-elle se présenter à la présidence des États-Unis ?"""
# La Constitution américaine stipule que vous devez être un citoyen né de père et de mère US *et* avoir au moins 35 ans
    return is_natural_born_citizen and (age >= 35)

print(can_run_for_president(19, True))
print(can_run_for_president(55, False))
print(can_run_for_president(55, True))
print(can_run_for_president(55, not True))
print(can_run_for_president(55, not False))

## Pouvez-vous deviner la valeur de cette expression ?
True or True and False

## Et de celle-ci ?
True and not True and False

Pour répondre à cette question, vous devez déterminer l'ordre des opérations.

Par exemple, and est évalué avant or. C'est pourquoi la première expression ci-dessus est True. Si nous l'évaluions de gauche à droite, nous aurions d'abord calculé True ou True (qui est True), puis pris le and de ce résultat avec False, ce qui donnerait une valeur finale de False.

Vous pouvez essayer de mémoriser l'ordre de priorité (https://docs.python.org/3/reference/expressions.html#operator-precedence), mais il est plus sûr d'utiliser généreusement les parenthèses. Cela permet non seulement d'éviter les bugs, mais aussi de clarifier vos intentions pour quiconque lit votre code.

Prenons par exemple l'expression suivante :

## qui renvoie un message d'erreur en l'état
prepared_for_weather = have_umbrella or rain_level < 5 and have_hood or not rain_level > 0 and is_workday

J'essaie de me dire que je suis à l'abri du mauvais temps aujourd'hui....

○ si j'ai un parapluie...
○ ou si la pluie n'est pas trop forte et que j'ai une capuche...
○ sinon, je vais bien à moins qu'il pleuve et que ce soit un jour ouvrable

Mais non seulement mon code Python est difficile à lire, mais il comporte également un bug. Nous pouvons résoudre ces deux problèmes en ajoutant quelques parenthèses :

prepared_for_weather = have_umbrella or (rain_level < 5 and have_hood) or not (rain_level > 0 and is_workday)

Vous pouvez ajouter encore plus de parenthèses si vous pensez que cela améliore la lisibilité :

prepared_for_weather = have_umbrella or ((rain_level < 5) and have_hood) or (not (rain_level > 0 and is_workday))

Nous pouvons également le diviser sur plusieurs lignes pour souligner la structure en 3 parties décrite ci-dessus :

prepared_for_weather = (

have_umbrella 

or ((rain_level < 5) and have_hood) 

or (not (rain_level > 0 and is_workday))

)

Il faudrait aussi définir have_umbrella, have_hood...

4. Les instructions conditionnelles

Les booléens sont particulièrement utiles lorsqu'ils sont combinés avec des instructions conditionnelles, à l'aide des mots-clés if, elif et else.

Les instructions conditionnelles, souvent appelées instructions if-then, vous permettent de contrôler les parties de code exécutées en fonction de la valeur d'une condition booléenne. Voici un exemple :

def inspect(x): # trad : vérifier/examiner
    if x == 0:
        print(x, "est nul")
    elif x > 0:
        print(x, "est positif")
    elif x < 0:
        print(x, "est négatif")
    else:
        print(x, "ne ressemble à rien de ce que j'ai déjà vu...")

inspect(0)
inspect(-15)

Les mots-clés if et else sont souvent utilisés dans d'autres langages ; son mot-clé le plus unique est elif, une contraction de "else if". Dans ces clauses conditionnelles, les blocs elif et else sont facultatifs ; de plus, vous pouvez inclure autant d'instructions elif que vous le souhaitez.

Notez en particulier l'utilisation des deux points (:) et des espaces pour désigner des blocs de code distincts. Cela ressemble à ce qui se passe lorsque nous définissons une fonction - l'en-tête de la fonction se termine par :, et la ligne suivante est indentée de 4 espaces. Toutes les lignes indentées suivantes appartiennent au corps de la fonction, jusqu'à ce que nous rencontrions une ligne non indentée, mettant fin à la définition de la fonction.

def f(x):
    if x > 0:
        print("Imprimé uniquement lorsque x est positif; x =", x)
        print("Imprimé également uniquement lorsque x est positif; x =", x)
        print("Toujours imprimé, quelle que soit la valeur de x; x =", x)

f(1)
f(0)

5. Conversion booléenne¶

Nous avons vu int(), qui transforme les objets en ints, et float(), qui transforme les objets en floats, vous ne serez donc peut-être pas surpris d'apprendre que Python a une fonction bool() qui transforme les objets en bools.

print(bool(1)) # tous les nombres sont traités comme vrais, sauf 0
print(bool(0))
print(bool("asf")) # toutes les chaînes sont traitées comme vraies, sauf la chaîne vide ""
print(bool(""))
# Généralement des séquences vides (chaînes, listes et autres types que nous n'avons pas encore vus comme les listes et les tuples)
# sont "falsifiés" et le reste est "vrai"

Nous pouvons utiliser des objets non booléens dans les conditions if et dans d'autres endroits où un booléen serait attendu. Python les traitera implicitement comme leur valeur booléenne correspondante :

if 0:
    print(0)
elif "spam":
    print("spam")