Opérateurs en Python

Cet article explique les opérateurs en Python.

YouTube Video

Opérateurs en Python

Python possède divers opérateurs, qui peuvent être largement classés comme suit. Nous expliquerons les opérateurs représentatifs de chaque catégorie.

Opérateurs arithmétiques

Les opérateurs arithmétiques sont des opérateurs utilisés pour effectuer des calculs sur les nombres.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• En plus des quatre opérations arithmétiques de base, Python propose des opérateurs pour la division (/), la division entière (//), le modulo (%) et l’exponentiation (**). La division renvoie un nombre à virgule flottante même lors de la division de nombres entiers.

Opérateurs d'affectation

Les opérateurs d’affectation sont utilisés pour attribuer des valeurs aux variables.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Les opérateurs d’affectation permettent de combiner l’affectation standard avec divers opérateurs pour affecter le résultat.
• L’opérateur morse (:=) est une expression d’affectation disponible à partir de Python 3.8.
• Alors que l’affectation standard ne peut être utilisée que comme instruction, l’opérateur morse permet une affectation au sein d’une expression.

Opérateurs de comparaison

Les opérateurs de comparaison comparent des valeurs et renvoient True ou False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Les opérateurs de comparaison comparent deux valeurs pour l’ordre ou l’égalité et renvoient True ou False en résultat.
• En Python, il faut faire attention lors de la comparaison de différents types de données. Certains types peuvent être comparés entre eux, mais les résultats peuvent ne pas être intuitifs.

Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner des expressions logiques.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and est un opérateur logique qui renvoie True uniquement si les deux conditions à gauche et à droite sont True.
• or est un opérateur logique qui renvoie True si l’une ou l’autre des conditions (gauche ou droite) est True.
• not est un opérateur logique qui inverse la valeur de vérité d’une condition. Si la condition est vraie, elle devient fausse, et si elle est fausse, elle devient vraie.

Priorité des opérateurs logiques

Les opérateurs ont une priorité. C'est la règle qui détermine quel opérateur est évalué en premier dans une expression. Les opérateurs logiques sont évalués dans l'ordre : not, puis and, puis or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

Dans le premier exemple, and est évalué en premier, donc False and False devient False, et par conséquent, True or False devient True. Vous pouvez également modifier l'ordre d'évaluation en utilisant des parenthèses, comme dans le deuxième exemple.

Opérateurs au niveau des bits

Les opérateurs logiques bit à bit effectuent des opérations au niveau des bits.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Vous pouvez effectuer des opérations logiques bit à bit AND, OR, XOR, NOT, ainsi que des décalages de bits. Vous pouvez également les combiner avec des opérateurs d’affectation tels que &=.

Opérateurs d'appartenance

Les opérateurs d'appartenance sont utilisés avec des collections telles que des listes et des dictionnaires.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• L'opérateur in est utilisé pour déterminer si une valeur spécifiée est contenue dans une séquence telle qu'une liste ou une chaîne de caractères, ou dans une collection telle qu'un dictionnaire.
• L'opérateur not in est utilisé pour déterminer si une valeur spécifiée n'est pas contenue dans une séquence ou une collection.

Opérateurs d'identité

Les opérateurs d'identité vérifient l'identité des objets.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• L’opérateur is vérifie si deux objets sont le même objet (c’est-à-dire qu’ils pointent vers la même adresse mémoire).
• L’opérateur is not vérifie si deux objets sont des objets différents.
• Par exemple, x is y diffère de x == y car il vérifie l’identité de l’objet, et non l’égalité des valeurs.

Vérification de type

En Python, on utilise la fonction isinstance() pour vérifier si une valeur est d'un type spécifique. Vous pouvez également utiliser la fonction type() pour vérifier le type exact d'une variable. Bien que ce ne soient pas des opérateurs, ce sont des mécanismes de base pour la vérification de type.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() est une fonction qui vérifie si un objet est une instance d’une classe spécifiée ou d’une de ses sous-classes.
• type() est une fonction qui renvoie le type exact (classe) d’un objet. Elle est généralement utilisée lorsqu'on souhaite effectuer une comparaison stricte de type.
• isinstance() prend en compte les relations d'héritage, alors que type() vérifie les correspondances exactes.

Résumé

Lors de l'utilisation de chaque opérateur, vous devez choisir de manière appropriée en fonction de son objectif et de son type. Comme Python est un langage typé dynamiquement, le résultat d'une opération peut varier en fonction du type de valeurs étant calculées.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video