Opérateurs Python
Opérateurs Python
Dans ce didacticiel, vous apprendrez tout sur les différents types d'opérateurs en Python, leur syntaxe et comment les utiliser avec des exemples.
Vidéo :Opérateurs en Python
Que sont les opérateurs en python ?
Les opérateurs sont des symboles spéciaux en Python qui effectuent des calculs arithmétiques ou logiques. La valeur sur laquelle l'opérateur opère s'appelle l'opérande.
Par exemple :
>>> 2+3
5
Ici, + est l'opérateur qui effectue l'addition. 2 et 3 sont les opérandes et 5 est la sortie de l'opération.
Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques telles que l'addition, la soustraction, la multiplication, etc.
| Opérateur | Signification | Exemple |
|---|---|---|
| + | Ajouter deux opérandes ou plus unaire | x + y+ 2 |
| - | Soustraire l'opérande droit du moins gauche ou unaire | x - y- 2 |
| * | Multiplier deux opérandes | x * y |
| / | Diviser l'opérande de gauche par celui de droite (résulte toujours en flottant) | x / y |
| % | Module - reste de la division de l'opérande gauche par la droite | x % y (reste de x/y) |
| // | Division d'étage - division qui se traduit par un nombre entier ajusté à gauche dans la ligne numérique | x // y |
| ** | Exposant - opérande de gauche élevé à la puissance de droite | x**y (x à la puissance y) |
Exemple 1 :Opérateurs arithmétiques en Python
x = 15
y = 4
# Output: x + y = 19
print('x + y =',x+y)
# Output: x - y = 11
print('x - y =',x-y)
# Output: x * y = 60
print('x * y =',x*y)
# Output: x / y = 3.75
print('x / y =',x/y)
# Output: x // y = 3
print('x // y =',x//y)
# Output: x ** y = 50625
print('x ** y =',x**y) Sortie
x + y = 19 x - y = 11 x * y = 60 x / y = 3.75 x // y = 3 x ** y = 50625
Opérateurs de comparaison
Les opérateurs de comparaison sont utilisés pour comparer des valeurs. Elle renvoie soit True ou False selon l'état.
| Opérateur | Signification | Exemple |
|---|---|---|
| > | Supérieur à - Vrai si l'opérande de gauche est supérieur à celui de droite | x> y |
| < | Inférieur à - Vrai si l'opérande de gauche est inférieur à celui de droite | x |
| == | Égal à - Vrai si les deux opérandes sont égaux | x ==y |
| != | Pas égal à - Vrai si les opérandes ne sont pas égaux | x !=y |
| >= | Supérieur ou égal à - Vrai si l'opérande de gauche est supérieur ou égal à celui de droite | x>=y |
| <= | Inférieur ou égal à - Vrai si l'opérande de gauche est inférieur ou égal à celui de droite | x <=y |
Exemple 2 :Opérateurs de comparaison en Python
x = 10
y = 12
# Output: x > y is False
print('x > y is',x>y)
# Output: x < y is True
print('x < y is',x<y)
# Output: x == y is False
print('x == y is',x==y)
# Output: x != y is True
print('x != y is',x!=y)
# Output: x >= y is False
print('x >= y is',x>=y)
# Output: x <= y is True
print('x <= y is',x<=y) Sortie
x > y is False x < y is True x == y is False x != y is True x >= y is False x <= y is True
Opérateurs logiques
Les opérateurs logiques sont les and , or , not opérateurs.
| Opérateur | Signification | Exemple |
|---|---|---|
| et | Vrai si les deux opérandes sont vrais | x et y |
| ou | Vrai si l'un des opérandes est vrai | x ou y |
| pas | Vrai si l'opérande est faux (complète l'opérande) | pas x |
Exemple 3 :Opérateurs logiques en Python
x = True
y = False
print('x and y is',x and y)
print('x or y is',x or y)
print('not x is',not x) Sortie
x and y is False x or y is True not x is False
Voici la table de vérité de ces opérateurs.
Opérateurs au niveau du bit
Les opérateurs au niveau du bit agissent sur les opérandes comme s'il s'agissait de chaînes de chiffres binaires. Ils fonctionnent petit à petit, d'où leur nom.
Par exemple, 2 est 10 en binaire et 7 est 111 .
Dans le tableau ci-dessous : Soit x =10 (0000 1010 en binaire) et y =4 (0000 0100 en binaire)
| Opérateur | Signification | Exemple |
|---|---|---|
| & | ET au niveau du bit | x &y =0 (0000 0000 ) |
| | | OU au niveau du bit | x | y =14 (0000 1110 ) |
| ~ | NON au niveau du bit | ~x =-11 (1111 0101 ) |
| ^ | XOR au niveau du bit | x ^ y =14 (0000 1110 ) |
| >> | Décalage au niveau du bit vers la droite | x>> 2 =2 (0000 0010 ) |
| < | Décalage bit à gauche | x <<2 =40 (0010 1000 ) |
Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés en Python pour affecter des valeurs aux variables.
a = 5 est un simple opérateur d'affectation qui affecte la valeur 5 à droite à la variable a à gauche.
Il existe différents opérateurs composés en Python comme a += 5 qui s'ajoute à la variable et lui attribue ensuite la même chose. Il équivaut à a = a + 5 .
| Opérateur | Exemple | Équivalent à |
|---|---|---|
| = | x =5 | x =5 |
| += | x +=5 | x =x + 5 |
| -= | x -=5 | x =x - 5 |
| *= | x *=5 | x =x * 5 |
| /= | x /=5 | x =x / 5 |
| %= | x %=5 | x =x % 5 |
| //= | x //=5 | x =x // 5 |
| **= | x **=5 | x =x ** 5 |
| &= | x &=5 | x =x &5 |
| |= | x |=5 | x =x | 5 |
| ^= | x ^=5 | x =x ^ 5 |
| >>= | x>>=5 | x =x>> 5 |
| <<= | x <<=5 | x =x <<5 |
Opérateurs spéciaux
Le langage Python offre certains types spéciaux d'opérateurs comme l'opérateur d'identité ou l'opérateur d'appartenance. Ils sont décrits ci-dessous avec des exemples.
Opérateurs d'identité
is et is not sont les opérateurs d'identité en Python. Ils servent à vérifier si deux valeurs (ou variables) se trouvent sur la même partie de la mémoire. Deux variables égales n'impliquent pas qu'elles soient identiques.
| Opérateur | Signification | Exemple |
|---|---|---|
| est | Vrai si les opérandes sont identiques (fait référence au même objet) | x est vrai |
| n'est pas | Vrai si les opérandes ne sont pas identiques (ne font pas référence au même objet) | x n'est pas vrai |
Exemple 4 :Opérateurs d'identité en Python
x1 = 5
y1 = 5
x2 = 'Hello'
y2 = 'Hello'
x3 = [1,2,3]
y3 = [1,2,3]
# Output: False
print(x1 is not y1)
# Output: True
print(x2 is y2)
# Output: False
print(x3 is y3) Sortie
False True False
Ici, nous voyons que x1 et y1 sont des nombres entiers de même valeur, ils sont donc égaux et identiques. Il en va de même avec x2 et y2 (chaînes).
Mais x3 et y3 sont des listes. Ils sont égaux mais pas identiques. C'est parce que l'interpréteur les situe séparément en mémoire bien qu'ils soient égaux.
Opérateurs d'adhésion
in et not in sont les opérateurs d'appartenance en Python. Ils sont utilisés pour tester si une valeur ou une variable se trouve dans une séquence (chaîne, liste, tuple, ensemble et dictionnaire).
Dans un dictionnaire, nous ne pouvons tester que la présence de la clé, pas la valeur.
| Opérateur | Signification | Exemple |
|---|---|---|
| dans | Vrai si la valeur/variable est trouvée dans la séquence | 5 en x |
| pas dans | Vrai si la valeur/variable n'est pas trouvée dans la séquence | 5 pas dans x |
Exemple 5 :Opérateurs d'appartenance en Python
x = 'Hello world'
y = {1:'a',2:'b'}
# Output: True
print('H' in x)
# Output: True
print('hello' not in x)
# Output: True
print(1 in y)
# Output: False
print('a' in y) Sortie
True True True False
Ici, 'H' est dans x mais 'hello' n'est pas présent dans x (rappelez-vous, Python est sensible à la casse). De même, 1 est la clé et 'a' est la valeur dans le dictionnaire y . Par conséquent, 'a' in y renvoie False .
Python