Python Opérateurs
Qu'est-ce qu'un opérateur ?
Ce chapitre explique principalement les opérateurs Python. Prenons un exemple simple 4 +5 = 9 Dans l'exemple,4et5est appeléopérande，+est appelé un opérateur.
Le langage Python prend en charge les types d'opérateurs suivants :
- Opérateurs arithmétiques
- Opérateurs de comparaison (relationnels)
- Opérateurs d'affectation
- Opérateurs logiques
- Opérateurs bit à bit
- Opérateurs d'appartenance
- Opérateurs d'identité
- Priorité des opérateurs
Ensuite, apprenons les opérateurs Python un par un.
Opérateurs arithmétiques Python
Ce qui suit suppose les variables : a=10，b=20：
| Operator | Description | Exemple |
|---|---|---|
| + | Addition - Additionne deux objets | a + b renvoie 30 |
| - | Soustraction - Donne un nombre négatif ou soustrait un nombre d'un autre | a - b renvoie -10 |
| * | Multiplication - Multiplie deux nombres ou renvoie une chaîne répétée un certain nombre de fois | a * b renvoie 200 |
| / | Division - x divisé par y | b / a renvoie 2 |
| % | Modulo - Renvoie le reste de la division | b % a renvoie 0 |
| ** | Exposant - Renvoie x élevé à la puissance y | a**b vaut 10 puissance 20, affiche 100000000000000000000 |
| // | Division entière - Renvoie la partie entière du quotient (arrondie vers le bas） |
>>> 9//2 4 >>> -9//2 -5 |
L'exemple suivant illustre les opérations de tous les opérateurs arithmétiques Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
c = a + b
print "1 - La valeur de c est :", c
c = a - b
print "2 - La valeur de c est :", c
c = a * b
print "3 - La valeur de c est :", c
c = a / b
print "4 - La valeur de c est :", c
c = a % b
print "5 - La valeur de c est :", c
# Modifier les valeurs des variables a, b, c
a = 2
b = 3
c = a**b
print "6 - La valeur de c est :", c
a = 10
b = 5
c = a//b
print "7 - La valeur de c est :", c
Exécuter l'exemple »
La sortie de l'exemple ci-dessus est :
1 - c 的值为： 31 2 - c 的值为： 11 3 - c 的值为： 210 4 - c 的值为： 2 5 - c 的值为： 1 6 - c 的值为： 8 7 - c 的值为： 2
Remarque :Dans Python 2.x, la division d'un entier par un entier ne peut donner qu'un entier. Si vous voulez la partie fractionnaire, changez l'un des nombres en un float.
>>> 1/2 0 >>> 1.0/2 0.5 >>> 1/float(2) 0.5
Opérateurs de comparaison Python
Ce qui suit suppose que la variable a vaut 10 et que la variable b vaut 20 :
| Operator | Description | Exemple |
|---|---|---|
| == | Égal à - Compare si les objets sont égaux | (a == b) renvoie False. |
| != | Différent de - Compare si deux objets ne sont pas égaux | (a != b) renvoie True. |
| <> | Différent de - Compare si deux objets ne sont pas égaux.Obsolète dans Python 3. | (a <> b) renvoie True. Cet opérateur est similaire à !=. |
| > | Supérieur à - Renvoie si x est supérieur à y | (a > b) renvoie False. |
| < | Inférieur à - Renvoie si x est inférieur à y. Tous les opérateurs de comparaison renvoient 1 pour vrai et 0 pour faux. Ils sont équivalents aux variables spéciales True et False, respectivement. | (a < b) renvoie True. |
| >= | Supérieur ou égal à - Renvoie si x est supérieur ou égal à y. | (a >= b) renvoie False. |
| <= | Inférieur ou égal à - Renvoie si x est inférieur ou égal à y. | (a <= b) renvoie True. |
L'exemple suivant illustre le fonctionnement de tous les opérateurs de comparaison Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
if a == b :
print "1 - a est égal à b"
else:
print "1 - a n'est pas égal à b"
if a != b :
print "2 - a n'est pas égal à b"
else:
print "2 - a est égal à b"
if a <> b :
print "3 - a n'est pas égal à b"
else:
print "3 - a est égal à b"
if a < b :
print "4 - a est inférieur à b"
else:
print "4 - a est supérieur ou égal à b"
if a > b :
print "5 - a est supérieur à b"
else:
print "5 - a est inférieur ou égal à b"
# Modifier les valeurs des variables a et b
a = 5
b = 20
if a <= b :
print "6 - a est inférieur ou égal à b"
else:
print "6 - a est supérieur à b"
if b >= a :
print "7 - b est supérieur ou égal à a"
else:
print "7 - b est inférieur à a"
La sortie de l'exemple ci-dessus est :
1 - a 不等于 b 2 - a 不等于 b 3 - a 不等于 b 4 - a 大于等于 b 5 - a 大于 b 6 - a 小于等于 b 7 - b 大于等于 a
Opérateurs d'affectation Python
Ce qui suit suppose que la variable a vaut 10 et que la variable b vaut 20 :
| Operator | Description | Exemple |
|---|---|---|
| = | Opérateur d'affectation simple | c = a + b affecte le résultat de a + b à c |
| += | Opérateur d'affectation par addition | c += a équivaut à c = c + a |
| -= | Opérateur d'affectation par soustraction | c -= a équivaut à c = c - a |
| *= | Opérateur d'affectation de multiplication | c *= a est équivalent à c = c * a |
| /= | Opérateur d'affectation de division | c /= a est équivalent à c = c / a |
| %= | Opérateur d'affectation modulo | c %= a est équivalent à c = c % a |
| **= | Opérateur d'affectation d'exposant | c **= a est équivalent à c = c ** a |
| //= | Opérateur d'affectation de division entière | c //= a est équivalent à c = c // a |
L'exemple suivant illustre les opérations de tous les opérateurs d'affectation Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 21
b = 10
c = 0
c = a + b
print "1 - La valeur de c est :", c
c += a
print "2 - La valeur de c est :", c
c *= a
print "3 - La valeur de c est :", c
c /= a
print "4 - La valeur de c est :", c
c = 2
c %= a
print "5 - La valeur de c est :", c
c **= a
print "6 - La valeur de c est :", c
c //= a
print "7 - La valeur de c est :", c
La sortie de l'exemple ci-dessus est :
1 - c 的值为： 31 2 - c 的值为： 52 3 - c 的值为： 1092 4 - c 的值为： 52 5 - c 的值为： 2 6 - c 的值为： 2097152 7 - c 的值为： 99864
Opérateurs bit à bit Python
Les opérateurs bit à bit traitent les nombres comme des binaires pour le calcul. Les règles des opérations bit à bit en Python sont les suivantes :
Dans le tableau ci-dessous, la variable a vaut 60 et b vaut 13, avec les formats binaires suivants :
a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
| Operator | Description | Exemple |
|---|---|---|
| & | Opérateur ET bit à bit : Pour les deux valeurs impliquées dans l'opération, si les deux bits correspondants sont 1, le bit de résultat est 1 ; sinon, il est 0. | (a & b) renvoie 12, explication binaire : 0000 1100 |
| | | Opérateur OU bit à bit : Si au moins un des deux bits binaires correspondants est 1, le bit de résultat est 1. | (a | b) renvoie 61, explication binaire : 0011 1101 |
| ^ | Opérateur OU exclusif bit à bit : Lorsque les deux bits binaires correspondants sont différents, le résultat est 1. | (a ^ b) renvoie 49, explication binaire : 0011 0001 |
| ~ | Opérateur NON bit à bit : Inverse chaque bit dans la représentation binaire, en changeant 0 en 1 et 1 en 0.~xSimilaire à-x-1 | (~a ) renvoie -61, explication binaire : 1100 0011 (représenté sous forme de complément à deux), dans la représentation en complément à deux d'un nombre binaire signé. |
| << | Opérateur de décalage à gauche : Tous les bits binaires de l'opérande sont décalés vers la gauche d'un nombre de bits, déterminé par<<Le nombre à droite spécifie le nombre de positions à décaler. Les bits d'ordre supérieur sont supprimés, et les bits d'ordre inférieur sont remplis avec 0. | a << 2 donne 240, explication binaire : 1111 0000 |
| >> | Opérateur de décalage à droite : décale tous les bits binaires de l'opérande à gauche de ">>" vers la droite du nombre de places spécifié,>>Le nombre à droite spécifie le nombre de positions à décaler. | a >> 2 donne 15, explication binaire : 0000 1111 |
L'exemple suivant illustre le fonctionnement de tous les opérateurs bit à bit en Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print "1 - la valeur de c est :", c
c = a | b; # 61 = 0011 1101
print "2 - la valeur de c est :", c
c = a ^ b; # 49 = 0011 0001
print "3 - la valeur de c est :", c
c = ~a; # -61 = 1100 0011
print "4 - la valeur de c est :", c
c = a << 2; # 240 = 1111 0000
print "5 - la valeur de c est :", c
c = a >> 2; # 15 = 0000 1111
print "6 - la valeur de c est :", c
La sortie de l'exemple ci-dessus est :
1 - c 的值为： 12 2 - c 的值为： 61 3 - c 的值为： 49 4 - c 的值为： -61 5 - c 的值为： 240 6 - c 的值为： 15
Opérateurs logiques Python
Le langage Python prend en charge les opérateurs logiques. Supposons que la variable a vaut 10 et b vaut 20 :
| Operator | Expression logique | Description | Exemple |
|---|---|---|---|
| et | x and y | Booléen « and » - Si x est False, x and y renvoie False, sinon il renvoie la valeur évaluée de y. | (a and b) renvoie 20. |
| ou | x or y | Booléen « or » - Si x est non nul, il renvoie la valeur évaluée de x, sinon il renvoie la valeur évaluée de y. | (a or b) renvoie 10. |
| not | not x | Booléen « not » - Si x est True, renvoie False. Si x est False, il renvoie True. | not(a and b) renvoie False |
La sortie de l'exemple ci-dessus est :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 10
b = 20
if a and b :
print "1 - les variables a et b sont toutes deux True"
else:
print "1 - l'une des variables a et b n'est pas True"
if a or b :
print "2 - les variables a et b sont toutes deux True, ou l'une des variables est True"
else:
print "2 - les variables a et b sont toutes deux non True"
# modifier la valeur de la variable a
a = 0
if a and b :
print "3 - les variables a et b sont toutes deux True"
else:
print "3 - l'une des variables a et b n'est pas True"
if a or b :
print "4 - les variables a et b sont toutes deux True, ou l'une des variables est True"
else:
print "4 - les variables a et b sont toutes deux non True"
if not( a and b ):
print "5 - les variables a et b sont toutes deux False, ou l'une des variables est False"
else:
print "5 - les variables a et b sont toutes deux True"
La sortie de l'exemple ci-dessus est :
1 - 变量 a 和 b 都为 True 2 - 变量 a 和 b 都为 True，或其中一个变量为 True 3 - 变量 a 和 b 有一个不为 True 4 - 变量 a 和 b 都为 True，或其中一个变量为 True 5 - 变量 a 和 b 都为 False，或其中一个变量为 False
Opérateurs d'appartenance de Python
En plus des opérateurs ci-dessus, Python prend également en charge les opérateurs d'appartenance, qui testent si une séquence contient une série de membres, notamment des chaînes de caractères, des listes ou des tuples.
| Operator | Description | Exemple |
|---|---|---|
| in | Renvoie True si la valeur est trouvée dans la séquence spécifiée, sinon renvoie False. | x in y séquence, renvoie True si x est dans la séquence y. |
| not in | Renvoie True si la valeur n'est pas trouvée dans la séquence spécifiée, sinon renvoie False. | x not in y sequence, renvoie True si x n'est pas dans la séquence y. |
L'exemple suivant illustre les opérations de tous les opérateurs d'appartenance en Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print "1 - la variable a est dans la liste donnée"
else:
print "1 - la variable a n'est pas dans la liste donnée"
if ( b not in list ):
print "2 - la variable b n'est pas dans la liste donnée"
else:
print "2 - la variable b est dans la liste donnée"
# modifier la valeur de la variable a
a = 2
if ( a in list ):
print "3 - la variable a est dans la liste donnée"
else:
print "3 - la variable a n'est pas dans la liste donnée"
La sortie de l'exemple ci-dessus est :
1 - 变量 a 不在给定的列表中 list 中 2 - 变量 b 不在给定的列表中 list 中 3 - 变量 a 在给定的列表中 list 中
Opérateurs d'identité Python
Les opérateurs d'identité sont utilisés pour comparer les emplacements mémoire de deux objets
| Operator | Description | Exemple |
|---|---|---|
| est | is détermine si deux identifiants font référence au même objet | x is y, similaire àid(x) == id(y), s'ils font référence au même objet, renvoie True ; sinon renvoie False |
| n'est pas | is not détermine si deux identifiants font référence à des objets différents | x is not y, similaire àid(a) != id(b). S'ils ne font pas référence au même objet, le résultat renvoie True ; sinon renvoie False. |
Remarque : id()La fonction est utilisée pour obtenir l'adresse mémoire d'un objet.
L'exemple suivant illustre le fonctionnement de tous les opérateurs d'identité en Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 20
if ( a is b ):
print "1 - a et b ont la même identité"
else:
print "1 - a et b n'ont pas la même identité"
if ( a is not b ):
print "2 - a et b n'ont pas la même identité"
else:
print "2 - a et b ont la même identité"
# modifier la valeur de la variable b
b = 30
if ( a is b ):
print "3 - a et b ont la même identité"
else:
print "3 - a et b n'ont pas la même identité"
if ( a is not b ):
print "4 - a et b n'ont pas la même identité"
else:
print "4 - a et b ont la même identité"
La sortie de l'exemple ci-dessus est :
1 - a 和 b 有相同的标识 2 - a 和 b 有相同的标识 3 - a 和 b 没有相同的标识 4 - a 和 b 没有相同的标识
Différence entre is et == :
is est utilisé pour déterminer si deux références de variable font référence au même objet (au même espace mémoire), == est utilisé pour déterminer si les valeurs des variables référencées sont égales.
>>> a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True
Précédence des opérateurs Python
Le tableau suivant répertorie tous les opérateurs, de la précédence la plus élevée à la plus faible :
| Operator | Description |
|---|---|
| ** | Exponentiation (précédence la plus élevée) |
| ~ + - | Inversion bit à bit, plus et moins unaires (les noms des méthodes pour les deux derniers sont +@ et -@) |
| * / % // | Multiplication, division, modulo et division entière |
| + - | Addition et soustraction |
| >> << | Opérateurs de décalage à droite et à gauche |
| & | ET bit à bit |
| ^ | | Opérateurs bit à bit |
| <= < > >= | Opérateurs de comparaison |
| <> == != | Opérateurs d'égalité |
| = %= /= //= -= += *= **= | Opérateurs d'affectation |
| is is not | Opérateurs d'identité |
| in not in | Opérateurs d'appartenance |
| not and or | Opérateurs logiques |
L'exemple suivant montre le fonctionnement de toutes les précédences d'opérateurs en Python :
Exemples (Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print "Le résultat de (a + b) * c / d est :", e
e = ((a + b) * c) / d # (30 * 15 ) / 5
print "Le résultat de ((a + b) * c) / d est :", e
e = (a + b) * (c / d); # (30) * (15/5)
print "Le résultat de (a + b) * (c / d) est :", e
e = a + (b * c) / d; # 20 + (150/5)
print "Le résultat de a + (b * c) / d est :", e
La sortie de l'exemple ci-dessus est :
(a + b) * c / d 运算结果为： 90 ((a + b) * c) / d 运算结果为： 90 (a + b) * (c / d) 运算结果为： 90 a + (b * c) / d 运算结果为： 50Autres extensions