Les opérateurs en Python

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. En Python, les opérateurs peuvent être classés dans les catégories suivantes:

  •   Opérateurs arithmétiques (+, -, *, /,%, //)
  •   Opérateurs relationnels (==,!=,>, < ,>= et <=) Opérateurs logiques (and, or et not)
  •   Opérateurs binaires (&, |, ^, ~, >> et <<)
  •   Opérateurs d'affectation (=, +=, -=, *=, etc)
  •   Opérateurs spéciaux (is, is not, in, not in)

Opérateurs arithmétiques

Ils sont utilisés pour effectuer des opérations arithmétiques/mathématiques sur les opérandes. Les opérateurs binaires appartenant à cette catégorie sont:

  •   Addition : L'opérateur ‘+’ ajoute deux opérandes. Par exemple, x+y.
  •   Soustraction: l'opérateur ‘ - ' soustrait deux opérandes. Par exemple, x-y.
  •   Multiplication: l'opérateur ’ * ' multiplie deux opérandes. Par exemple, x*y.
  •   Division: l'opérateur '/' divise le premier opérande par le second. Par exemple, x/y.
  •   Module: l'opérateur ' % ' renvoie le reste lorsque le premier opérande est divisé par le second. Par exemple, x%y).
  •   Division entière (//): Lorsque nous divisons des entiers avec //, le quotient est également un entier.
  •   Exposant (**) : l'opérande gauche élevé à la puissance de droite. Par exemple, x**2
Exemple 1 :
                                a = 10
                                b = 4
                                res = a + b; # addition
                                print("a+b : ", res)
                                            
                                res = a - b; # soustraction
                                print("a-b :", res)
                                            
                                res = a * b; # multiplication
                                print("a*b :", res)
                                            
                                res = a / b; # division
                                print("a/b : ", res)
                                            
                                res = a % b; # Module
                                print("a mod b :", res)

                                res = a // b; # division entière
                                print("a // b :", res)
                                            
                            
a+b : 14
a-b : 6
a*b : 40
a/b : 2.5
a mod b : 2
a // b : 2

Opérateurs relationnels et logiques

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer deux valeurs.

  •   l'opérateur ‘==’ vérifie si les deux opérandes sont égales ou non. Si oui, il renvoie la valeur true. Sinon, il retourne false. Par exemple, 5==5 retournera true.
  •   ‘!=’ opérateur vérifie si les deux opérandes sont égaux ou non. elle renvoie la valeur true si les deux opérandes ne sont pas égaux, Sinon, il retourne false. C'est le complément booléen exact de l'opérateur‘==’. Par exemple, 5!=5 retournera false.
  •   L’opérateur ‘>’ vérifie si le premier opérande est supérieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6> 5 retournera true.
  •   L’opérateur ‘<‘ vérifie si le premier opérande est inférieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6 < 5 renverra false. <
  •   L’opérateur ‘> =’ vérifie si le premier opérande est supérieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5> = 5 retournera true.
  •   L’opérateur ‘<=’ vérifie si le premier opérande est inférieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5 <=5 retournera également true.
Exemple 2 :
                                a = 10
                                b = 4
                                            
                                # supérieure à
                                if a > b:
                                    print("a est supérieure à b")
                                else:
                                    print("a est inférieure ou égale à b")
                                            
                                # supérieure ou égale
                                if (a >= b):
                                    print("a est supérieure ou égale à b")
                                else:
                                    print("a est inférieure à b")
                                            
                                # inférieure à
                                if (a < b):
                                    print("a est inférieure à b")
                                else:
                                    print("a est supérieure ou égal b")
                                            
                                # inférieure ou égale
                                if (a <= b):
                                    print("a est inférieure ou égale à b")
                                else:
                                    print("a est supérieure à b")
                                            
                                # égales
                                if (a == b):
                                    print("les valeurs a et b sont égales")
                                else:
                                    print("a et b ne sont pas égales")
                                            
                                # ne sont pas égales
                                if (a != b):
                                    print("les valeurs a et b ne sont pas égales ")
                                else:
                                    print("les valeurs a et b sont égales b")
                            
a est supérieure à b
a est supérieure ou égale à b
a est supérieure ou égal b
a est supérieure à b
a et b ne sont pas égales
les valeurs a et b ne sont pas égales
Opérateurs logiques

Ils sont utilisés pour combiner deux ou plusieurs conditions / contraintes ou pour compléter l'évaluation de la condition d'origine considérée.
Ils sont décrits ci-dessous:

  •  

    ET logique: l’opérateur "and" retourne True lorsque les deux conditions considérées sont remplies. Sinon, il retourne False.
    Par exemple, a and b renvoie True lorsque a et b sont vraies (c'est-à-dire différentes de zéro).

  •  

    OU logique: l’opérateur "or" renvoie la valeur True lorsque l’une (ou les deux) des conditions considérées est remplie. Sinon, il retourne False.
    Par exemple, un a or b renvoie True si l'un des a ou b est True (c'est-à-dire différente de zéro). Bien sûr, il retourne True lorsque a et b sont toutes les deux vraies.

  •  

    NON logique: L’opérateur "not" Renvoie True si la condition considérée n’est pas remplie. Sinon, il retourne False

Exemple 3 :
                                a = 10
                                b = 4
                                c = 10
                                d = 20
                                            
                                # ET logique
                                if (a > b and c == d):
                                    print("a est supérieure à b ET c est égale à d\n")
                                else:
                                    print("condition ET non satisfaite\n")
                                            
                                # OU logique
                                if (a > b or c == d):
                                    print("a est supérieure à b OU c est égale à d\n")
                                else:
                                    print("Ni a n'est supérieure à b ni c n'est égale à d ")
                                            
                                # NON logique
                                if (!a):
                                    print("a est zéro\n")
                                else:
                                    print("a est différente de zero")

                            
condition ET non satisfaite
a est supérieure à b OU c est égale à d
a est différente de zero

Opérateurs d'affectation

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

OperateurExempleEquivalente à
=x = 5x = 5
+=x += 5x = x + 5
-=x -= 5x = x - 5
*=x *= 5x = x * 5
/=x /= 5x = x / 5
%=x %= 5x = x % 5
//=x //= 5x = x // 5
**=x **= 5x = x ** 5
&=x &= 5x = x & 5
|=x |= 5x = x | 5
^=x ^= 5x = x ^ 5
>>=x >>= 5x = x >> 5
<<=x <<= 5x = x << 5

Opérateurs binaires

Les opérateurs binaires sont utilisés pour effectuer des opérations sur les bits. Toutes les valeurs décimales seront converties en valeurs binaires (séquence de bits, à savoir 0100, 1100, 1000, 1001, etc.). Ensuite, les opérateurs au niveau des bits travailleront sur ces bits, en les décalant de gauche à droite ou en convertissant les valeurs de bits de 0 à 1, etc.

Dans le tableau ci-dessous: Soit x = 10 (0000 1010 en binaire) et y = 4 (0000 0100 en binaire)

OperateursignificationExemple
&ET logiquex& y = 0 (0000 0000)
|OU logiquex | y = 14 (0000 1110)
~NON logique~x = -11 (1111 0101)
^XORx ^ y = 14 (0000 1110)
>>Décalage binaire à droitex>> 2 = 2 (0000 0010)
<<Décalage binaire à gauchex<< 2 = 40 (0010 1000)

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) sont situées sur la même emplacement mémoire. deux variables égales n'impliquent pas qu'elles sont identiques.

OperateursignificationExemple
isTrue si les opérandes sont identiques (se référer au même objet)x is True
is notTrue si les opérandes ne sont pas identiques (pas de référence pour le même objet)x is not True
Opérateur d'appartenance

"in" et "not in" sont les opérateurs d'appartenance en Python. Ils sont utilisés pour tester si une valeur ou une variable est trouvée dans une séquence (chaîne, liste, tuple, set et dictionnaire).

Dans un dictionnaire, nous pouvons uniquement tester la présence de la clé, pas la valeur.

OperateursignificationExemple
inTrue si la valeur / variable se trouve dans la séquence5 in x
not inTrue si la valeur / variable ne se trouve pas dans la séquence5 not in x

Rédigé par M. ESSADDOUKI

Many people realize their hearts desires late in life. Continue learning, never stop striving and keep your curiosity sharp, and you will never become too old to appreciate life.