Aller au contenu

Opérateurs

Les opérateurs sont des symboles ou des mots réservés, utilisés pour réaliser des opérations entre des opérandes.
Un opérande est une variable, un littéral ou bien une expression.
Une expression est une suite valide d'opérateurs et d'opérandes.

Opérateurs arithmétiques

Remarque

Seul le cas d'opérandes à valeurs numériques est envisagé ici.

Addition
L'expression a + b a pour valeur la somme des deux opérandes a et b.

a = 10
b = 3
a + b
13

Soustraction
L'expression a - b a pour valeur la différence des deux opérandes a et b.

a = 10
b = 3
a - b
7

Multiplication
L'expression a * b a pour valeur le produit des deux opérandes a et b.

a = 10
b = 3
a * b
30

Division
L'expression a / b a pour valeur le quotient décimal dans la division de a par b.

a = 10
b = 3
a / b
3.3333333333333335

Modulo
L'expression a % b a pour valeur le reste dans la division entière de a par b.

a = 10
b = 3
a % b
1

Division entière
L'expression a // b a pour valeur le quotient dans la division entière de a par b.

a = 10
b = 3
a // b
3

Exposant
L'expression a ** b a pour valeur aexposant b : a b .

a = 10
b = 3
a ** b
1000

Opérateurs de comparaison

Les opérateurs de comparaison (ou relationnels) sont utilisés pour comparer les valeurs de deux opérandes. L'expression s'écrit sous la forme d'une relation (de comparaison) : elle vaut Truesi les valeurs des opérandes vérifient la relation et False sinon.

signifie "est égal à ".
Exemple : 2 * 3 == 5 vaut False

signifie "n'est pas égal à ".
Exemple : 2 * 3 != 5 vaut True

signifie "est supérieur à ".
Exemple : 2 * 3 > 5 vaut True

signifie "est supérieur ou égal à ".
Exemple : 2 * 3 >= 5 vaut True

signifie "est inférieur à ".
Exemple : 2 * 3 < 5 vaut False

signifie "est inférieur ou égal à ".
Exemple : 2 * 3 < 5 vaut False

Opérateurs logiques

Remarque

Seul le cas d'opérandes à valeurs booléennes est envisagé ici.

ET logique
L'expression a and b vaut True si (et seulement si) les deux opérandes a et b valent True.
Exemple : 2 * 3 > 5 and 2 + 3 == 5 vaut True

OU logique
L'expression a or b vaut True si (et seulement si) au moins l'un des deux opérandes a et b vaut True.
Exemple : 2 * 3 < 5 or 2 + 3 == 5 vaut True

NON logique (opérateur unaire1)
L'expression not a vaut True si avaut False; elle vaut Falsesinon.
Exemple : not (2 * 3 < 5) vaut True

Opérateurs binaires

Les opérateurs binaires (ou bit à bit) appliquent des opérateurs logiques sur les bits de l'écriture binaire des opérandes.

Et bit à bit
a & b : on détermine le résultat bit à bit à l'aide d'un ET logique entre les bits de l'écriture binaire de aet b.
Exemple :

a = 240   # soit 1111 0000 en binaire
b = 170   # soit 1010 1010 en binaire
a & b
160       # soit 1010 0000 en binaire

Ou bit à bit
a | b : on détermine le résultat bit à bit à l'aide d'un OU logique entre les bits de l'écriture binaire de aet b.
Exemple :

a = 240   # soit 1111 0000 en binaire
b = 170   # soit 1010 1010 en binaire
a | b
250       # soit 1111 1010 en binaire

Ou exclusif bit à bit (xor)
a ^ b : on détermine le résultat bit à bit à l'aide d'un OU exclusif (XOR) entre les bits de l'écriture binaire de aet b.
Exemple :

a = 240   # soit 1111 0000 en binaire
b = 170   # soit 1010 1010 en binaire
a ^ b
90        # soit 0101 1010 en binaire

Inversion bit à bit (opérateur unaire1)
~ a : on détermine le résultat bit à bit à l'aide d'un NON sur les bits de l'écriture binaire de a.
Exemple :

a = 240   # soit 1111 0000 en binaire
~ a
15        # soit 0000 1111 en binaire

Décalage bit à bit droite
a >> b : on détermine le résultat en décalant les bits de l'écriture binaire de a de b rangs vers la droite.
Exemple :

a = 48   # soit 0011 0000 en binaire
a >> 2
12       # soit 0000 1100  en binaire

Décalage bit à bit gauche
a << b : on détermine le résultat en décalant les bits de l'écriture binaire de a de b rangs vers la gauche.
Exemple :

a = 48   # soit 0011 0000 en binaire
a << 2
192      # soit 1100 0000 en binaire

Opérateurs d'affectation

Les opérateurs d’affectation sont utilisés pour attribuer une valeur à une variable. La variable est l'opérande de gauche. La valeur est l'opérande de droite : il est évalué avant l'affectation.

En dehors de l'affectation à l'aide du symbole =, les autres opérateurs, dits d'affectation augmentée, combinent une opération arithmérique ou binaire et une affectation de valeur à une variable, préalablement initialisée.

Opérateur d'affectation
Exemples :
x = 2 : affecte à x la valeur 2.
x = 2*3 + 5 : affecte à x la valeur 11.
x = y : affecte à x la valeur de y (qui doit avoir été initialisée préalablement)

Exemple :
x += 2 : augmente la valeur de x de 2.
Équivalent à x = x + 2

Exemple :
x -= 2 : diminue la valeur de x de 2.
Équivalent à x = x - 2

Exemple :
x *= 2 : multiplie la valeur de x par 2.
Équivalent à x = x * 2

Exemple :
x /= 2 : divise la valeur de x par 2.
Équivalent à x = x / 2

Exemple :
x %= 2 : remplace x par le reste de la division de la valeur de xpar 2.
Équivalent à x = x % 2

Exemple :
x //= 2 : divise la valeur de x par 2 (quotient entier).
Équivalent à x = x // 2

Exemple :
x **= 2 : élève x à la puissance 2.
Équivalent à x = x ** 2

Exemple :
x &= 2
Équivalent à x = x & 2

Exemple :
x |= 2
Équivalent à x = x | 2

Exemple :
x ^= 2
Équivalent à x = x ^ 2

Exemple :
x >>= 2
Équivalent à x = x >> 2

Exemple :
x <<= 2
Équivalent à x = x << 2

Opérateurs spéciaux

Le langage Python offre des types d'opérateurs spéciaux, tels que l'opérateur d'identité ou l'opérateur d'appartenance.

Opérateur d'identité

is et is not sont les opérateurs d'identité en Python. Ils permettent de vérifier si deux valeurs (ou variables) référencent (ou non) le même emplacement mémoire.
Deux variables de même valeur ne sont pas nécessairement identiques.

a is b vaut True si les opérandes aet b référencent le même objet. Exemple :

tableau1 = [1, 2, 3]
tableau2 = tableau1
tableau1 is tableau2
True

a is not b vaut True si les opérandes aet b ne référencent pas le même objet. Exemple :

tableau1 = [1, 2, 3]
tableau2 = [1, 2, 3]
tableau1 is not tableau2
True

Opérateur d'appartenance

in et not in sont les opérateurs d'appartenance en Python. Ils sont utilisés pour vérifier si une valeur est présente (ou non) dans une séquence (chaîne, liste, tuple, set et dictionnaire).

a in b vaut True si l'opérande a se trouve dans la séquence b.
Exemple :

tableau = [1, 2, 3]
a = 2
a in tableau
True

a not in b vaut True si l'opérande ane se trouve pas dans la séquence b.
Exemple :

tableau = [1, 2, 3]
a = 4
a not in tableau
True

Priorités des opérateurs

Liste des opérateurs, de la priorité la plus haute à la plus basse :
**
* / // %
+ -
< <= > >= == !=
=
not
and
or


  1. opérateur ne nécessitant qu'un opérande 

Retour en haut de la page