Les Opérateurs en Python : Syntaxe, Priorités et Évaluation Court-Circuit

Classification des opérateurs fondamentaux

Python met à disposition plusieurs familles d'opérateurs pour manipuler des valeurs, réaliser des calculs et orienter le flux d'exécution d'un programme.

Opérateurs arithmétiques

Opérateur Description Exemple
+ Addition 5 + 3 renvoie 8
- Soustraction 10 - 4 renvoie 6
* Multiplication 3 * 4 renvoie 12
/ Division flottante 7 / 2 renvoie 3.5
% Modulo (reste de la division) 10 % 3 renvoie 1
** Exponentiation 2 ** 3 renvoie 8
// Division entière 9 // 2 renvoie 4

Opérateurs de comparaison

Opérateur Description
== Égalité stricte des valeurs
!= Inégalité
> Supérieur à
< Inférieur à
>= Supérieur ou égal
<= Inférieur ou égal

Opérateurs logiques

Opérateur Desrciption
and Renvoie True uniquement si les deux opérandes sont vrais
or Renvoie True si au moins un opérande est vrai
not Inverse la valeur booléenne de l'opérande

Opérateurs d'affectation

Opérateur Description Équivalence
= Affectation simple x = y
+= Addition puis affectation x = x + y
-= Soustraction puis affectation x = x - y
*= Multiplication puis affectation x = x * y
/= Division puis affectation x = x / y
%= Modulo puis affectation x = x % y
**= Exponentiation puis affectation x = x ** y
//= Division entière puis affectation x = x // y

Opérateurs d'appartenance

Opérateur Description Exemple
in Vrai si l'élément est présent dans la séquence 'a' in 'abc' → True
not in Vrai si l'élément est absent de la séquence 'z' not in 'abc' → True

Hiérarchie et priorité d'évaluation

L'interpréteur Python appilque des règles de priorité strictes lors du traitement des expressions composées. Les opérations mathématiques sont résolues avant les comparaisons, lesquelles sont évaluées avant les connecteurs logiques.

1. Arithmétique prioritaire sur la comparaison

if 4 + 6 > 9:
    print("Condition validée")
else:
    print("Condition rejetée")

2. Comparaison prioritaire sur la logique

if 5 > 2 and 1 < 0:
    print("Vrai")
else:
    print("Faux")

3. Priorité interne aux opérateurs logiques : not > and > or

# not est traité en premier, puis and, enfin or
resultat = not False and True or False
print(resultat)  # Affiche True

Règle pratique : L'ordre décroissant de priorité est arithmétique > comparaison > not > and > or. Pour éviter toute ambiguïté et améliorer la lisibilité, encadrez systématiquement les expressions complexes avec des parenthèses.

Mécanisme d'évaluaiton court-circuit

Contrairement à de nombreux langages, les opérateurs and et or en Python ne renvoient pas systématiquement un booléen. Ils appliquent une évaluation paresseuse et retournent directement la valeur de l'opérande qui détermine le résultat.

  • and : si le premier opérande est faux (falsy), il est retourné immédiatement. Sinon, la valeur du second opérande est renvoyée.
  • or : si le premier opérande est vrai (truthy), il est retourné immédiatement. Sinon, la valeur du second opérande est renvoyée.
# Comportement de and
res_1 = "donnee" and 100      # "donnee" est truthy → retourne 100
res_2 = "" and 100            # "" est falsy → retourne ""

# Comportement de or
res_3 = 0 or 250              # 0 est falsy → retourne 250
res_4 = "python" or 250       # "python" est truthy → retourne "python"

print(res_1, res_2, res_3, res_4)

Lorsque and et or coexistent dans une même expression, and est toujours évalué en premier. L'usage explicite de parenthèses reste fortement recommandé pour garantir un comportement prévisible.

Exercices d'application

1. Contrôle d'accès avec limite de tentatives

Concevez un script d'authentification autorisant trois essais maximum. À chaque échec, le programme doit indiquer le nombre de tentatives restantes.

MAX_TENTATIVES = 3
IDENTIFIANT_CIBLE = "utilisateur"
MOT_DE_PASSE_CIBLE = "s3cur3"

for essai in range(1, MAX_TENTATIVES + 1):
    saisie_id = input("Identifiant : ")
    saisie_mdp = input("Mot de passe : ")

    if saisie_id == IDENTIFIANT_CIBLE and saisie_mdp == MOT_DE_PASSE_CIBLE:
        print("Authentification réussie.")
        break
    else:
        restantes = MAX_TENTATIVES - essai
        print(f"Échec. Il reste {restantes} tentative(s).")

2. Devinette numérique (version standard)

L'utilisateur doit deviner un nombre entier prédéfini. Le programme s'arrête après trois propositions incorrectes ou dès que la bonne valeur est trouvée.

VALEUR_SECRETE = 42
compteur = 0

while compteur < 3:
    entree = input("Proposez un nombre : ")
    if not entree.isdigit():
        print("Veuillez saisir un entier valide.")
        continue

    proposition = int(entree)
    compteur += 1

    if proposition == VALEUR_SECRETE:
        print("Bravo, cible atteinte !")
        break
    else:
        print(f"Incorrect. Essais restants : {3 - compteur}")

3. Devinette numérique avec relance conditionnelle

Amélioration du jeu précédent : après trois échecs consécutifs, le programme demande si l'utilisateur souhaite recommencer une nouvelle série de trois essais. La saisie de O réinitialise le compteur, tandis que N termine l'exécution.

CIBLE = 27
LIMIT = 3
essais_courants = 0

while True:
    saisie = input("Entrez un nombre : ")
    if not saisie.lstrip('-').isdigit():
        print("Format invalide.")
        continue

    nombre = int(saisie)
    essais_courants += 1

    if nombre == CIBLE:
        print("Félicitations, vous avez gagné !")
        break

    print(f"Mauvaise réponse. {LIMIT - essais_courants} essai(s) dans cette manche.")

    if essais_courants >= LIMIT:
        choix = input("Rejouer une manche ? (O/N) : ").strip().upper()
        if choix == "O":
            essais_courants = 0
            print("Nouvelle série initialisée.")
        else:
            print("Partie terminée.")
            break

Étiquettes: Python opérateurs-python priorité-opérateurs évaluation-court-circuit structures-conditionnelles

Publié le 26 septembre à 16h02