Python3 opérateurs

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

Ce chapitre explique principalement les opérateurs de Python.

Prenons un exemple simple :

4 + 5 = 9

Dans l'exemple,4et5est appeléopérande，+appelé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 de Python un par un.

Opérateurs arithmétiques Python

Ce qui suit suppose que la variablea=10, variableb=21：

>>> 9//2
4
>>> -9//2
-5

L'exemple suivant démontre le fonctionnement de tous les opérateurs arithmétiques en Python :

L'exemple ci-dessus produit :

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

Opérateurs de comparaison Python

Ce qui suit suppose que la variable a vaut 10 et que la variable b vaut 20 :

L'exemple suivant démontre le fonctionnement de tous les opérateurs de comparaison en Python :

L'exemple ci-dessus produit :

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

Opérateurs d'affectation Python

Ce qui suit suppose que la variable a vaut 10 et que la variable b vaut 20 :

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

L'exemple suivant montre le fonctionnement de tous les opérateurs d'affectation en Python :

L'exemple ci-dessus produit :

1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864

À partir de Python 3.8, une nouvelle fonctionnalité de syntaxe appelée « Walrus » a été introduite, qui utilise le symbole:=. L'objectif principal de cet opérateur est de réaliser une affectation et de renvoyer la valeur affectée dans une expression.

L'utilisation de l'opérateur walrus peut simplifier le code dans certains cas, lorsque vous devez utiliser la valeur dans une expression. Cela est utile pour simplifier les conditions de boucle et les calculs répétés dans les expressions.

Un exemple simple démontrant l'utilisation de l'opérateur walrus :

• if (n := 10) > 5:: Ceci est l'opérateur walrus (:=: L'opérateur walrus effectue une opération d'affectation dans une expression.
  • (n := 10): Affecte la variablenà 10 et renvoie la valeur affectée en même temps.
  • > 5: Vérifie si lanest supérieure à 5. Si la condition est vraie, exécutez le bloc de code suivant.
• print(n): Si la condition est vraie, affichez la variablen(c'est-à-dire 10).

Avantages de l'opérateur walrus :

• L'opérateur walrus (:=) permet une affectation au sein d'une expression, ce qui peut réduire la duplication de code et améliorer la lisibilité et la concision du code.
• Dans l'exemple ci-dessus, l'approche traditionnelle nécessite une ligne séparée pour affectern, puisifinstruction pour vérifier la condition. Avec l'opérateur walrus, le code peutifeffectuer directement l'affectation et la vérification de la condition au sein de l'instruction.

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. Les formats binaires sont les suivants :

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

Les exemples suivants illustrent le fonctionnement de tous les opérateurs bit à bit de Python :

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. Ce qui suit suppose que la variable a vaut 10 et b vaut 20 :

La sortie de l'exemple ci-dessus est :

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. L'instance de test contient une série de membres, notamment des chaînes de caractères, des listes ou des tuples.

Les exemples suivants illustrent le fonctionnement de tous les opérateurs d'appartenance de Python :

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.

Remarque : id()La fonction est utilisée pour obtenir l'adresse mémoire d'un objet.

Les exemples suivants illustrent le fonctionnement de tous les opérateurs d'identité Python :

La sortie de l'exemple ci-dessus est :

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

La différence entre is et == :

is est utilisé pour déterminer si deux variables font référence au même objet ; == 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 priorité la plus élevée à la plus faible. Les opérateurs dans la même cellule ont la même priorité. Les opérateurs se rapportent à des opérations binaires, sauf indication contraire. Les opérateurs dans la même cellule sont regroupés de gauche à droite (sauf l’exponentiation, qui est regroupée de droite à gauche) :

Les exemples suivants illustrent le fonctionnement de toutes les règles de priorité des opérateurs Python :

La sortie de l'exemple ci-dessus est :

(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0

and a une priorité plus élevée :

L'exemple ci-dessus évalue d'abordy and zet renvoie False, puisx or Falserenvoie True, et le résultat affiché est :

情况1：默认优先级（先算and）
yes

情况2：强制改变优先级（先算or）
no

Remarque :Python3 ne prend plus en charge l'opérateur<>, vous pouvez utiliser!=à la place, si vous avez vraiment besoin d'utiliser cet opérateur de comparaison, vous pouvez utiliser la méthode suivante :

>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True

x = True
y = False
z = False

if x or y and z:
    print("yes")
else:
    print("no")

x = True
y = False
z = False

if not x or y:
    print(1)
elif not x or not y and z:
    print(2)
elif not x or y or not y and x:
    print(3)
else:
    print(4)