À l'issue de ce chapitre, vous serez capable de manipuler efficacement tous les types d'opérateurs Python : arithmétiques (+, -, *, /), de comparaison (==, !=, <, >), logiques (and, or, not) et d'affectation (=, +=, -=). Vous comprendrez leur priorité d'exécution et leur utilisation dans des expressions complexes. Ces compétences sont essentielles pour effectuer des calculs, créer des conditions et construire la logique de vos programmes Python.
Les opérateurs sont des symboles ou mots-clés qui permettent d'effectuer des opérations sur des données. Ils sont l'un des éléments fondamentaux de tout langage de programmation et permettent de manipuler, comparer et combiner des valeurs.
Un opérateur est un symbole spécial qui indique au compilateur ou à l'interpréteur d'effectuer une opération spécifique sur une ou plusieurs valeurs (appelées opérandes).
La structure générale d'une opération est :
# opérande1 opérateur opérande2 a = 5 + 3 # 5 et 3 sont les opérandes, + est l'opérateur resultat = 10 * 2 # 10 et 2 sont les opérandes, * est l'opérateur
Python propose plusieurs catégories d'opérateurs :
Les opérateurs arithmétiques permettent d'effectuer des calculs mathématiques sur des nombres. Ils constituent la base de tout calcul en programmation.
Les quatre opérations de base :
# Opérateurs arithmétiques de base a = 10 b = 3 # Addition addition = a + b print(f"Addition : {a} + {b} = {addition}") # 13 # Soustraction soustraction = a - b print(f"Soustraction : {a} - {b} = {soustraction}") # 7 # Multiplication multiplication = a * b print(f"Multiplication : {a} * {b} = {multiplication}") # 30 # Division division = a / b print(f"Division : {a} / {b} = {division}") # 3.3333333333333335
Important à retenir :
+ fonctionne aussi avec les chaînes (concaténation)* peut répéter des chaînes ou des listes/ retourne toujours un nombre décimal (float)Python propose deux opérateurs supplémentaires pour la division :
a = 17 b = 5 # Division normale division = a / b print(f"Division : {a} / {b} = {division}") # 3.4 # Division entière (floor division) division_entiere = a // b print(f"Division entière : {a} // {b} = {division_entiere}") # 3 # Modulo (reste de la division) reste = a % b print(f"Modulo : {a} % {b} = {reste}") # 2 # Vérification : a = (a // b) * b + (a % b) verification = (a // b) * b + (a % b) print(f"Vérification : {verification} = {a}") # 17 = 17
Applications pratiques du modulo :
nombre % 2 == 0L'opérateur ** permet d'élever un nombre à une puissance :
# Exponentiation base = 2 exposant = 3 puissance = base ** exposant print(f"{base} puissance {exposant} = {puissance}") # 8 # Exemples pratiques print(f"2³ = {2**3}") # 8 print(f"5² = {5**2}") # 25 print(f"10⁴ = {10**4}") # 10000 # Racine carrée (exposant fractionnaire) racine_carree = 16 ** 0.5 print(f"Racine de 16 = {racine_carree}") # 4.0
Les opérateurs de comparaison permettent de comparer des valeurs et retournent toujours un booléen (True ou False).
Les opérateurs de base pour tester l'égalité :
a = 5 b = 5 c = 10 # Égalité (==) print(f"{a} == {b} : {a == b}") # True print(f"{a} == {c} : {a == c}") # False # Inégalité (!=) print(f"{a} != {b} : {a != b}") # False print(f"{a} != {c} : {a != c}") # True # Attention : ne pas confondre = (affectation) et == (comparaison) x = 10 # Affectation resultat = (x == 10) # Comparaison
Les opérateurs pour comparer des grandeurs :
a = 7 b = 12 # Plus petit que (<) print(f"{a} < {b} : {a < b}") # True # Plus grand que (>) print(f"{a} > {b} : {a > b}") # False # Plus petit ou égal (<=) print(f"{a} <= {b} : {a <= b}") # True print(f"{a} <= {a} : {a <= a}") # True # Plus grand ou égal (>=) print(f"{b} >= {a} : {b >= a}") # True print(f"{a} >= {a} : {a >= a}") # True # Comparaisons en chaîne x = 5 est_dans_intervalle = 1 < x < 10 print(f"1 < {x} < 10 : {est_dans_intervalle}") # True
Les chaînes de caractères peuvent aussi être comparées :
# Comparaison de chaînes mot1 = "Python" mot2 = "Python" mot3 = "Java" print(f'"{mot1}" == "{mot2}" : {mot1 == mot2}') # True print(f'"{mot1}" == "{mot3}" : {mot1 == mot3}') # False # Comparaison alphabétique (ordre lexicographique) print(f'"{mot3}" < "{mot1}" : {mot3 < mot1}') # True (J vient avant P) # Sensibilité à la casse mot4 = "python" print(f'"{mot1}" == "{mot4}" : {mot1 == mot4}') # False print(f'"{mot1}".lower() == "{mot4}" : {mot1.lower() == mot4}') # True
Les opérateurs logiques permettent de combiner plusieurs conditions booléennes. Ils sont essentiels pour créer des conditions complexes.
L'opérateur and retourne True uniquement si toutes les conditions sont vraies :
# Table de vérité de AND print("Table de vérité AND :") print(f"True and True = {True and True}") # True print(f"True and False = {True and False}") # False print(f"False and True = {False and True}") # False print(f"False and False = {False and False}") # False # Exemple pratique age = 25 a_permis = True peut_conduire = age >= 18 and a_permis print(f"Peut conduire : {peut_conduire}") # True
L'opérateur or retourne True si au moins une des conditions est vraie :
# Table de vérité de OR print("Table de vérité OR :") print(f"True or True = {True or True}") # True print(f"True or False = {True or False}") # True print(f"False or True = {False or True}") # True print(f"False or False = {False or False}") # False # Exemple pratique est_weekend = False est_vacances = True peut_dormir_tard = est_weekend or est_vacances print(f"Peut dormir tard : {peut_dormir_tard}") # True
L'opérateur not inverse la valeur booléenne :
# Table de vérité de NOT print("Table de vérité NOT :") print(f"not True = {not True}") # False print(f"not False = {not False}") # True # Exemples pratiques il_pleut = False beau_temps = not il_pleut print(f"Beau temps : {beau_temps}") # True # Combinaison d'opérateurs logiques temperature = 22 conditions_ideales = not il_pleut and temperature > 20 print(f"Conditions idéales : {conditions_ideales}") # True
Les opérateurs d'affectation permettent d'assigner des valeurs aux variables. Python propose plusieurs variantes pour simplifier les opérations courantes.
L'opérateur d'affectation de base est le signe égal = :
# Affectation simple x = 10 nom = "Alice" est_actif = True print(f"x = {x}, nom = {nom}, est_actif = {est_actif}") # Affectations multiples a = b = c = 5 # Toutes les variables valent 5 print(f"a = {a}, b = {b}, c = {c}") # Affectation parallèle (unpacking) x, y = 10, 20 print(f"x = {x}, y = {y}") # Échange de valeurs x, y = y, x print(f"Après échange : x = {x}, y = {y}")
Les opérateurs d'affectation composés combinent une opération avec l'affectation :
x = 10 # Addition et affectation (+=) x += 5 # Équivalent à : x = x + 5 print(f"x += 5 : {x}") # 15 # Soustraction et affectation (-=) x -= 3 # Équivalent à : x = x - 3 print(f"x -= 3 : {x}") # 12 # Multiplication et affectation (*=) x *= 2 # Équivalent à : x = x * 2 print(f"x *= 2 : {x}") # 24 # Division et affectation (/=) x /= 4 # Équivalent à : x = x / 4 print(f"x /= 4 : {x}") # 6.0 # Autres opérateurs composés y = 17 y //= 5 # Division entière print(f"y //= 5 : {y}") # 3 z = 17 z %= 5 # Modulo print(f"z %= 5 : {z}") # 2 w = 2 w **= 3 # Exponentiation print(f"w **= 3 : {w}") # 8
Les opérateurs composés sont très utiles pour :
Python propose des opérateurs spéciaux pour tester l'identité des objets et l'appartenance à des collections.
Les opérateurs is et is not testent si deux variables référencent le même objet en mémoire :
# Différence entre == et is a = [1, 2, 3] b = [1, 2, 3] c = a print(f"a == b : {a == b}") # True (même contenu) print(f"a is b : {a is b}") # False (objets différents) print(f"a is c : {a is c}") # True (même objet) # Utilisation avec None valeur = None print(f"valeur is None : {valeur is None}") # True print(f"valeur is not None : {valeur is not None}") # False # Cas particulier des petits entiers (cache Python) x = 100 y = 100 print(f"x is y : {x is y}") # True (cache des entiers -5 à 256) x = 1000 y = 1000 print(f"x is y : {x is y}") # False (hors cache)
Les opérateurs in et not in testent si un élément appartient à une séquence :
# Appartenance dans une liste fruits = ["pomme", "banane", "orange"] print(f'"pomme" in fruits : {"pomme" in fruits}') # True print(f'"kiwi" in fruits : {"kiwi" in fruits}') # False print(f'"kiwi" not in fruits : {"kiwi" not in fruits}') # True # Appartenance dans une chaîne phrase = "Python est fantastique" print(f'"Python" in phrase : {"Python" in phrase}') # True print(f'"Java" in phrase : {"Java" in phrase}') # False # Appartenance dans un dictionnaire (teste les clés) personne = {"nom": "Alice", "age": 30, "ville": "Paris"} print(f'"nom" in personne : {"nom" in personne}') # True print(f'"Alice" in personne : {"Alice" in personne}') # False (valeur, pas clé) print(f'"Alice" in personne.values() : {"Alice" in personne.values()}') # True # Appartenance dans un range nombres = range(1, 11) # 1 à 10 print(f'5 in range(1, 11) : {5 in nombres}') # True print(f'15 in range(1, 11) : {15 in nombres}') # False
Comme en mathématiques, Python respecte un ordre de priorité pour évaluer les expressions complexes. Comprendre cette priorité est essentiel pour éviter les erreurs.
Voici l'ordre de priorité des opérateurs Python (du plus prioritaire au moins prioritaire) :
# Ordre de priorité (du plus prioritaire au moins prioritaire): # 1. () - Parenthèses # 2. ** - Exponentiation # 3. +x, -x, not x - Plus/moins unaire, not # 4. *, /, //, % - Multiplication, division # 5. +, - - Addition, soustraction # 6. ==, !=, <, <=, >, >=, is, is not, in, not in - Comparaisons # 7. and - ET logique # 8. or - OU logique # Exemples de priorité resultat1 = 2 + 3 * 4 # Multiplication d'abord print(f"2 + 3 * 4 = {resultat1}") # 14 (pas 20) resultat2 = 2 ** 3 ** 2 # Exponentiation de droite à gauche print(f"2 ** 3 ** 2 = {resultat2}") # 512 (2^(3^2) = 2^9) resultat3 = 10 > 5 and 3 < 7 # Comparaisons avant and print(f"10 > 5 and 3 < 7 = {resultat3}") # True resultat4 = not 5 > 10 or 3 == 3 # not, puis comparaisons, puis or print(f"not 5 > 10 or 3 == 3 = {resultat4}") # True
Les parenthèses permettent de forcer l'ordre d'évaluation et rendent le code plus lisible :
# Sans parenthèses vs avec parenthèses a, b, c = 2, 3, 4 # Sans parenthèses (priorité naturelle) resultat1 = a + b * c print(f"Sans parenthèses : {a} + {b} * {c} = {resultat1}") # 14 # Avec parenthèses (changement de priorité) resultat2 = (a + b) * c print(f"Avec parenthèses : ({a} + {b}) * {c} = {resultat2}") # 20 # Parenthèses pour la lisibilité age = 25 salaire = 35000 experience = 3 # Moins lisible eligible = age >= 18 and salaire > 30000 or experience > 5 # Plus lisible avec parenthèses eligible_clair = (age >= 18 and salaire > 30000) or (experience > 5) print(f"Éligible : {eligible_clair}") # True # Parenthèses imbriquées complexe = ((a + b) * c) ** 2 / (a * b) print(f"Expression complexe : {complexe}") # 66.66...
Bonnes pratiques pour les parenthèses :
Mettons en pratique les opérateurs Python avec des exercices concrets et des cas d'usage réels.
Voici des exercices progressifs pour maîtriser les opérateurs :
# Exercice 1: Calculateur de base print("=== Exercice 1: Calculateur ===") nombre1 = 15 nombre2 = 7 print(f"Addition : {nombre1} + {nombre2} = {nombre1 + nombre2}") print(f"Soustraction : {nombre1} - {nombre2} = {nombre1 - nombre2}") print(f"Multiplication : {nombre1} * {nombre2} = {nombre1 * nombre2}") print(f"Division : {nombre1} / {nombre2} = {nombre1 / nombre2:.2f}") print(f"Division entière : {nombre1} // {nombre2} = {nombre1 // nombre2}") print(f"Modulo : {nombre1} % {nombre2} = {nombre1 % nombre2}") print(f"Puissance : {nombre1} ** {nombre2} = {nombre1 ** nombre2}") # Exercice 2: Vérification de parité print("\n=== Exercice 2: Parité ===") nombres = [12, 17, 24, 33, 40] for nombre in nombres: est_pair = nombre % 2 == 0 parite = "pair" if est_pair else "impair" print(f"{nombre} est {parite}") # Exercice 3: Système de notes print("\n=== Exercice 3: Système de notes ===") note = 85 excellent = note >= 90 bien = note >= 70 and note < 90 passable = note >= 50 and note < 70 echec = note < 50 print(f"Note : {note}/100") print(f"Excellent (≥90) : {excellent}") print(f"Bien (70-89) : {bien}") print(f"Passable (50-69) : {passable}") print(f"Échec (<50) : {echec}") # Exercice 4: Gestion d'inventaire print("\n=== Exercice 4: Inventaire ===") stock_initial = 100 commande1 = 25 commande2 = 30 livraison = 50 stock_actuel = stock_initial print(f"Stock initial : {stock_actuel}") stock_actuel -= commande1 print(f"Après commande 1 (-{commande1}) : {stock_actuel}") stock_actuel -= commande2 print(f"Après commande 2 (-{commande2}) : {stock_actuel}") stock_actuel += livraison print(f"Après livraison (+{livraison}) : {stock_actuel}") stock_critique = stock_actuel < 20 print(f"Stock critique (< 20) : {stock_critique}")
Voici des exemples d'utilisation réelle des opérateurs dans des programmes pratiques :
# Cas 1: Calculateur d'IMC (Indice de Masse Corporelle) print("=== Calculateur d'IMC ===") poids = 70 # kg taille = 1.75 # m imc = poids / (taille ** 2) print(f"IMC : {imc:.1f}") sous_poids = imc < 18.5 normal = 18.5 <= imc < 25 surpoids = 25 <= imc < 30 obesite = imc >= 30 if sous_poids: print("Catégorie : Sous-poids") elif normal: print("Catégorie : Poids normal") elif surpoids: print("Catégorie : Surpoids") else: print("Catégorie : Obésité") # Cas 2: Système de remise dynamique print("\n=== Système de remise ===") prix_unitaire = 25.99 quantite = 12 est_client_fidele = True est_premiere_commande = False total_brut = prix_unitaire * quantite print(f"Total brut : {total_brut:.2f}€") # Calcul des remises remise_quantite = 0.1 if quantite >= 10 else 0 remise_fidelite = 0.05 if est_client_fidele else 0 remise_premiere = 0.15 if est_premiere_commande else 0 # Les remises ne se cumulent pas, on prend la meilleure meilleure_remise = max(remise_quantite, remise_fidelite, remise_premiere) montant_remise = total_brut * meilleure_remise total_final = total_brut - montant_remise print(f"Remise appliquée : {meilleure_remise*100:.0f}% (-{montant_remise:.2f}€)") print(f"Total final : {total_final:.2f}€") # Cas 3: Validation de mot de passe print("\n=== Validation de mot de passe ===") mot_de_passe = "MonMotDePasse123!" # Critères de validation longueur_ok = len(mot_de_passe) >= 8 a_majuscule = any(c.isupper() for c in mot_de_passe) a_minuscule = any(c.islower() for c in mot_de_passe) a_chiffre = any(c.isdigit() for c in mot_de_passe) a_special = any(c in "!@#$%^&*" for c in mot_de_passe) mot_de_passe_valide = longueur_ok and a_majuscule and a_minuscule and a_chiffre and a_special print(f"Mot de passe testé : {mot_de_passe}") print(f"Longueur ≥ 8 : {longueur_ok}") print(f"Contient majuscule : {a_majuscule}") print(f"Contient minuscule : {a_minuscule}") print(f"Contient chiffre : {a_chiffre}") print(f"Contient caractère spécial : {a_special}") print(f"Mot de passe valide : {mot_de_passe_valide}") # Cas 4: Calcul d'âge et catégorie print("\n=== Calcul d'âge ===") annee_actuelle = 2024 annee_naissance = 1990 age = annee_actuelle - annee_naissance est_mineur = age < 18 est_adulte = 18 <= age < 65 est_senior = age >= 65 peut_voter = age >= 18 peut_conduire = age >= 18 tarif_reduit = est_mineur or est_senior print(f"Âge : {age} ans") print(f"Peut voter : {peut_voter}") print(f"Peut conduire : {peut_conduire}") print(f"Bénéficie du tarif réduit : {tarif_reduit}")
Ces exercices montrent comment les opérateurs Python sont utilisés dans des situations réelles :
Pour approfondir votre maîtrise des opérateurs, essayez de créer vos propres programmes utilisant :
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!