Guide complet des opérateurs Python : Arithmétiques, Logiques, Comparaison, Affectation, Bitwise et Priorité

Que sont les opérateurs logiques en Python ?

Les opérateurs logiques en Python évaluent des expressions booléennes et retournent True ou False. Les trois opérateurs logiques principaux sont and, or et not. Ils sont indispensables pour contrôler le flux avec if, while et autres instructions conditionnelles.

Dans ce tutoriel, nous explorerons tout le spectre des opérateurs Python, y compris :

• Opérateurs arithmétiques
• Opérateurs de comparaison
• Opérateurs d'affectation
• Opérateurs logiques & bitwise
• Opérateurs d'appartenance
• Opérateurs d'identité
• Priorité des opérateurs

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs numériques. Python supporte les opérateurs habituels : + (addition), - (soustraction), * (multiplication), / (division réelle), // (division euclidienne), % (modulo), et ** (exponentiation). Ils peuvent être utilisés directement dans les expressions ou via la fonction intégrée eval() pour évaluation dynamique.

Exemple : Addition simple

x = 4
y = 5
print(x + y) # Sortie : 9

Les autres opérateurs fonctionnent de même ; par exemple, 4 * 5 donne 20, 4 / 2 donne 2.0, et 4 ** 2 résulte en 16.

Opérateurs de comparaison

Les opérateurs de comparaison (relationnels) évaluent la relation entre deux valeurs et retournent un résultat booléen. Ils incluent :

• == (égal)
• != (différent)
• < (inférieur à)
• <= (inférieur ou égal à)
• > (supérieur à)
• >= (supérieur ou égal à)

Exemple : Comparaison de deux variables

x = 4
y = 5
print('x > y est', x > y) # Sortie : False

Opérateurs d'affectation

Les opérateurs d'affectation stockent des valeurs dans des variables. La forme de base est =, tandis que les opérateurs composés combinent une opération avec l'affectation, comme +=, -=, *=, /= et **=.

Exemple : Affectation de base et composée

num1 = 4
num2 = 5
print('Ligne 1 - Valeur de num1 :', num1)
print('Ligne 2 - Valeur de num2 :', num2)
# Addition composée
res = num1 + num2
res += num1
print('Ligne 3 - Résultat après res += num1 :', res) # Sortie : 13

Opérateurs logiques et bitwise

Les opérateurs logiques (and, or, not) évaluent des expressions booléennes. Les opérateurs bitwise (&, |, ^, ~, <<, >>) effectuent une manipulation au niveau des bits.

Exemple : Opérations logiques

a = True
b = False
print('a and b est', a and b) # Sortie : False
print('a or b est', a or b) # Sortie : True
print('not a est', not a) # Sortie : False

Opérateurs d'appartenance

Les opérateurs d'appartenance testent la présence d'une valeur dans une séquence : in et not in.

Exemple : Vérification d'appartenance dans une liste

x = 4
y = 8
liste_exemple = [1, 2, 3, 4, 5]
if x in liste_exemple:
    print('Ligne 1 - x est disponible dans la liste')
else:
    print('Ligne 1 - x n\'est pas disponible dans la liste')
if y not in liste_exemple:
    print('Ligne 2 - y n\'est pas disponible dans la liste')
else:
    print('Ligne 2 - y est disponible dans la liste')

Opérateurs d'identité

Les opérateurs d'identité comparent les adresses mémoire des objets : is et is not. Ils sont essentiels pour distinguer des objets égaux en valeur mais distincts en identité.

Exemple : Comparaison d'identité

x = 20
y = 20
if x is y:
    print('x et y ont la même identité')
y = 30
if x is not y:
    print('x et y ont des identités différentes')

Priorité des opérateurs

Python suit une hiérarchie de priorité stricte pour résoudre les expressions sans parenthèses. La priorité la plus haute est l'exponentiation (**), suivie des opérateurs unaires, multiplication/division/modulo, addition/soustraction, opérateurs de comparaison, opérateurs d'identité, opérateurs d'appartenance, opérateurs logiques, et enfin opérateurs d'affectation.

L'utilisation de parenthèses outrepassse la priorité par défaut et rend les expressions explicites.

Exemple : Priorité en action

v = 4
w = 5
x = 8
y = 2
z = (v + w) * x / y
print('Valeur de (v + w) * x / y est', z) # Sortie : 28.0

Compatibilité Python 2

Voici des extraits équivalents pour Python 2, qui utilise des instructions print sans parenthèses.

# Opérateurs Arithmétiques
x = 4
y = 5
print x + y
# Opérateurs de Comparaison
x = 4
y = 5
print 'x > y est', x > y
# Opérateurs d'Affectation
num1 = 4
num2 = 5
print 'Ligne 1 - Valeur de num1:', num1
print 'Ligne 2 - Valeur de num2:', num2
# Affectation Composee
num1 = 4
num2 = 5
res = num1 + num2
res += num1
print 'Ligne 3 - Résultat après res += num1:', res
# Opérateurs Logiques
a = True
b = False
print 'a and b est', a and b
print 'a or b est', a or b
print 'not a est', not a
# Opérateurs d'Appartenance
x = 4
y = 8
liste_exemple = [1, 2, 3, 4, 5]
if x in liste_exemple:
    print 'Ligne 1 - x est disponible dans la liste'
else:
    print 'Ligne 1 - x n\'est pas disponible dans la liste'
if y not in liste_exemple:
    print 'Ligne 2 - y n\'est pas disponible dans la liste'
else:
    print 'Ligne 2 - y est disponible dans la liste'
# Opérateurs d'Identité
x = 20
y = 20
if x is y:
    print 'x et y ont la même identité'
y = 30
if x is not y:
    print 'x et y ont des identités différentes'
# Priorité des Opérateurs
v = 4
w = 5
x = 8
y = 2
z = (v + w) * x / y
print 'Valeur de (v + w) * x / y est', z

Résumé

• Les opérateurs arithmétiques gèrent les calculs numériques.
• Les opérateurs de comparaison déterminent la vérité relationnelle.
• Les opérateurs d'affectation stockent des valeurs ; variantes composées combinent opérations.
• Les opérateurs logiques régissent le contrôle de flux ; opérateurs bitwise manipulent les bits.
• Les opérateurs d'appartenance testent l'appartenance à une séquence.
• Les opérateurs d'identité comparent les identités d'objets.
• La priorité des opérateurs dicte l'ordre d'évaluation ; les parenthèses peuvent l'outrepasser.