img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 4 : Opérateurs

À 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.

3.1 Introduction aux Opérateurs

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.

3.1.1 Qu'est-ce qu'un opérateur ?

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 :

Structure d'une opération
# 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

3.1.2 Types d'opérateurs en Python

Python propose plusieurs catégories d'opérateurs :

  • Opérateurs arithmétiques : pour les calculs mathématiques (+, -, *, /, etc.)
  • Opérateurs de comparaison : pour comparer des valeurs (==, !=, <, >, etc.)
  • Opérateurs logiques : pour les opérations logiques (and, or, not)
  • Opérateurs d'affectation : pour assigner des valeurs (=, +=, -=, etc.)
  • Opérateurs d'identité : pour comparer l'identité d'objets (is, is not)
  • Opérateurs d'appartenance : pour tester l'appartenance (in, not in)

3.2 Opérateurs Arithmétiques

Les opérateurs arithmétiques permettent d'effectuer des calculs mathématiques sur des nombres. Ils constituent la base de tout calcul en programmation.

3.2.1 Addition, soustraction, multiplication, division

Les quatre opérations de base :

operateurs_base.py
# 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 :

  • L'opérateur + fonctionne aussi avec les chaînes (concaténation)
  • L'opérateur * peut répéter des chaînes ou des listes
  • La division / retourne toujours un nombre décimal (float)

3.2.2 Division entière et modulo

Python propose deux opérateurs supplémentaires pour la division :

division_avancee.py
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 :

  • Vérifier si un nombre est pair ou impair : nombre % 2 == 0
  • Créer des cycles (ex: jour de la semaine)
  • Limiter une valeur dans une plage donnée

3.2.3 Exponentiation

L'opérateur ** permet d'élever un nombre à une puissance :

exponentiation.py
# 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

3.3 Opérateurs de Comparaison

Les opérateurs de comparaison permettent de comparer des valeurs et retournent toujours un booléen (True ou False).

3.3.1 Égalité et inégalité

Les opérateurs de base pour tester l'égalité :

egalite.py
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

3.3.2 Comparaisons numériques

Les opérateurs pour comparer des grandeurs :

comparaisons_numeriques.py
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

3.3.3 Comparaison de chaînes

Les chaînes de caractères peuvent aussi être comparées :

comparaison_chaines.py
# 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

3.4 Opérateurs Logiques

Les opérateurs logiques permettent de combiner plusieurs conditions booléennes. Ils sont essentiels pour créer des conditions complexes.

3.4.1 L'opérateur AND

L'opérateur and retourne True uniquement si toutes les conditions sont vraies :

operateur_and.py
# 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

3.4.2 L'opérateur OR

L'opérateur or retourne True si au moins une des conditions est vraie :

operateur_or.py
# 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

3.4.3 L'opérateur NOT

L'opérateur not inverse la valeur booléenne :

operateur_not.py
# 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

3.5 Opérateurs d'Affectation

Les opérateurs d'affectation permettent d'assigner des valeurs aux variables. Python propose plusieurs variantes pour simplifier les opérations courantes.

3.5.1 Affectation simple

L'opérateur d'affectation de base est le signe égal = :

affectation_simple.py
# 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}")

3.5.2 Affectations composées

Les opérateurs d'affectation composés combinent une opération avec l'affectation :

affectations_composees.py
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 :

  • Raccourcir le code et le rendre plus lisible
  • Incrémenter/décrémenter des compteurs
  • Accumuler des valeurs dans des boucles
  • Modifier des éléments de listes ou dictionnaires

3.6 Opérateurs d'Identité et d'Appartenance

Python propose des opérateurs spéciaux pour tester l'identité des objets et l'appartenance à des collections.

3.6.1 Opérateurs d'identité (is, is not)

Les opérateurs is et is not testent si deux variables référencent le même objet en mémoire :

operateurs_identite.py
# 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)

3.6.2 Opérateurs d'appartenance (in, not in)

Les opérateurs in et not in testent si un élément appartient à une séquence :

operateurs_appartenance.py
# 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

3.7 Priorité des Opérateurs

Comme en mathématiques, Python respecte un ordre de priorité pour évaluer les expressions complexes. Comprendre cette priorité est essentiel pour éviter les erreurs.

3.7.1 Ordre de priorité

Voici l'ordre de priorité des opérateurs Python (du plus prioritaire au moins prioritaire) :

priorite_operateurs.py
# 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

3.7.2 Utilisation des parenthèses

Les parenthèses permettent de forcer l'ordre d'évaluation et rendent le code plus lisible :

parentheses.py
# 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 :

  • Utilisez les parenthèses pour clarifier des expressions complexes
  • N'hésitez pas à en mettre "trop" plutôt que pas assez
  • Séparez les conditions logiques complexes avec des parenthèses
  • Testez vos expressions pour vous assurer qu'elles s'évaluent correctement

3.8 Exercices Pratiques

Mettons en pratique les opérateurs Python avec des exercices concrets et des cas d'usage réels.

3.8.1 Exercices guidés

Voici des exercices progressifs pour maîtriser les opérateurs :

exercices_guides.py
# 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}")

3.8.2 Cas d'usage concrets

Voici des exemples d'utilisation réelle des opérateurs dans des programmes pratiques :

cas_usage_concrets.py
# 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 :

  • Calculs mathématiques : IMC, prix avec remises
  • Conditions logiques complexes : validation de données, éligibilité
  • Manipulation de données : gestion d'inventaire, catégorisation
  • Validation et contrôle : sécurité, contraintes métier

Pour approfondir votre maîtrise des opérateurs, essayez de créer vos propres programmes utilisant :

  • Un convertisseur de devises avec commissions
  • Un système de notation automatique
  • Un calculateur de taxes et réductions
  • Un validateur de données de formulaire
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits