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