Caractère séquentiel des opérateurs booléens

Mise en évidence

Pour mettre en évidence le caractère séquentiel de certains opérateurs booléens en Python, on va démontrer que les opérateurs and et or évaluent leurs opérandes de gauche à droite.
Cela signifie que Python évalue toujours le premier opérande avant le second, et dans le cas des opérateurs paresseux (and et or), il peut ne pas évaluer le second opérande si le résultat peut être déterminé uniquement à partir du premier.

Voici un script Python qui illustre le caractère séquentiel des opérateurs booléens :

Opérateurs and et orOpérateurs & (ET binaire) et | (OU binaire)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def retourne_vrai():
    print("Fonction retourne_vrai exécutée")
    return True
def retourne_faux():
    print("Fonction retourne_faux exécutée")
    return False
def retourne_vrai_droite():
    print("Fonction retourne_vrai_droite exécutée")
    return True
def retourne_faux_droite():
    print("Fonction retourne_faux_droite exécutée")
    return False
print("Démonstration de l'opérateur 'and' (séquentiel et paresseux) :")
resultat_and = retourne_faux() and retourne_vrai_droite()
print("Résultat de 'and':", resultat_and)
print("\nDémonstration de l'opérateur 'or' (séquentiel et paresseux) :")
resultat_or = retourne_vrai() or retourne_faux_droite()
print("Résultat de 'or':", resultat_or)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

>>>

x

Évaluations restantes : ∞/∞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def retourne_vrai():
    print("Fonction retourne_vrai exécutée")
    return True
def retourne_faux():
    print("Fonction retourne_faux exécutée")
    return False
def retourne_vrai_droite():
    print("Fonction retourne_vrai_droite exécutée")
    return True
def retourne_faux_droite():
    print("Fonction retourne_faux_droite exécutée")
    return False
print("\nDémonstration de l'opérateur '&' (séquentiel et non paresseux) :")
resultat_bitwise_and = retourne_faux() & retourne_vrai_droite()
print("Résultat de '&':", resultat_bitwise_and)
print("\nDémonstration de l'opérateur '|' (séquentiel et non paresseux) :")
resultat_bitwise_or = retourne_vrai() | retourne_faux_droite()
print("Résultat de '|':", resultat_bitwise_or)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

>>>

x

Évaluations restantes : ∞/∞

Explication du code

1. Définition des fonctions

Les fonctions retourne_vrai et retourne_faux affichent un message et renvoient respectivement True et False. Les fonctions retourne_vrai_droite et retourne_faux_droite servent à montrer l’évaluation de l'opérande de droite.

2. Opérateur and (séquentiel et paresseux)

resultat_and = retourne_faux() and retourne_vrai_droite()
Comportement attendu : La fonction retourne_faux est exécutée en premier et retourne False. Puisque and est paresseux, Python n’évalue pas retourne_vrai_droite car le résultat est déjà déterminé à False.

3. Opérateur or (séquentiel et paresseux)

resultat_or = retourne_vrai() or retourne_faux_droite()
Comportement attendu : La fonction retourne_vrai est exécutée en premier et retourne True. Puisque or est paresseux, Python n’évalue pas retourne_faux_droite car le résultat est déjà déterminé à True.

4. Opérateur & (séquentiel et non paresseux)

resultat_bitwise_and = retourne_faux() & retourne_vrai_droite()
Comportement attendu : L’opérateur & évalue les deux opérandes indépendamment du résultat de la première évaluation. Ainsi, les deux fonctions retourne_faux et retourne_vrai_droite sont exécutées dans l'ordre.

5. Opérateur | (séquentiel et non paresseux)

resultat_bitwise_or = retourne_vrai() | retourne_faux_droite()
Comportement attendu : L’opérateur | évalue les deux opérandes indépendamment du résultat de la première évaluation. Ainsi, les deux fonctions retourne_vrai et retourne_faux_droite sont exécutées dans l'ordre.

Conclusion

Les opérateurs and et or sont paresseux et évaluent les opérandes de gauche à droite.
Les opérateurs & et | sont non paresseux mais restent séquentiels, évaluant toujours les deux opérandes de gauche à droite.