Opérateurs en Python

Contenus de la page

Je suis un développeur de logiciels avec un grand intérêt pour l’analyse de données et les statistiques.

Python prend en charge les types d’opérateurs suivants :

Opérateurs arithmétiques
Opérateurs de comparaison
Opérateurs d’affectation
Opérateurs logiques
Opérateurs au niveau du bit
Opérateurs d’adhésion
Opérateurs d’identité

Découvrons en détail chacun de ces opérateurs.

Opérateurs arithmétiques en Python

Presque tous les opérateurs pris en charge dans des langages tels que C/C++ ou Java sont pris en charge en Python. Les opérateurs +, -, / , * et % représentent respectivement l’addition, la soustraction, la division, la multiplication et le module. En plus de cela, ** effectue un calcul exponentiel et // effectue une division de plancher. Pour des raisons de brièveté de l’article, nous nous concentrerons davantage sur les opérateurs propres à Python.

#!/usr/bin/python3
# following code demonstrates use of exponential operator.
x = 10
y = 3
print(x, " ** ", y, "=", x**y)  # output: 10  **  3 = 1000

Le code suivant illustre l’utilisation de l’opération de plancher. Dans la division d’étage, si le numérateur est un nombre positif, le résultat est arrondi vers zéro. Si le numérateur est négatif, le résultat est arrondi à partir de zéro.

#!/usr/bin/python3
 
# floor division with positive numerator
a = 10
b = 5.2
print(a,"/", b, "=", a/b) # output: 10 / 5.2 = 1.923076923076923
print(a,"//", b, "=", a//b) # output: 10 // 5.2 = 1.0
 
# floor division with negative numerator
a = -10
b = 5.2
print(a,"/", b, "=", a/b) # output: -10 / 5.2 = -1.923076923076923
print(a,"//", b, "=", a//b) # output: -10 // 5.2 = -2.0

Opérateurs de comparaison Python

Presque tous les opérateurs de comparaison pris en charge par des langages comme C/C++ ou Java sont pris en charge par Python. Les opérateurs ==, !=. >,<, >= et <= désignent respectivement égal à, non égal à, supérieur à, inférieur à, supérieur ou égal à et inférieur ou égal à.

Opérateurs d’affectation en Python

Le symbole égal (=) est utilisé par Python pour attribuer une valeur du côté droit de l’expression à la variable du côté gauche. Comme d’autres langages comme C++ et Java, Python prend en charge les opérations Operator-And où le résultat de l’opération est affecté à gauche.

#!/usr/bin/python3
# demonstration of assignment operators
c = 10
d = 20
print("original value of c", c) # output: original value of c 10
print("original value of d", d) # output: original value of d 20
c+= d
print("New value of c after performing c+=d ",c) # output: New value of c after performing c+=d  30
c-=d 
print("New value of c after performing c-=d", c) # output: New value of c after performing c-=d 10

Comme l’opération +=, tous les autres opérateurs arithmétiques disponibles en Python peuvent être matraqués avec le symbole égal pour formuler les opérateurs Opérateur-Et respectifs.

Faites défiler pour continuer

Opérateurs logiques

ET, OU et NE PAS sont les trois opérateurs logiques de base pris en charge par Python.

#!/usr/bin/python3
# demonstration of logical operators
exp1 = True
exp2 = False
 
print("exp1 and exp2 = ", (exp1 and exp2)) # output: exp1 and exp2 =  False
print("exp1 or exp2 = ", (exp1 or exp2)) # output: exp1 or exp2 =  True
print(" Not(exp1) = ", not(exp1)) # output: Not(exp1) =  False

Opérateurs au niveau du bit

Python prend en charge AND(&), OR(|), XOR(^), One’s compliment ou flipping of bits(~), left shift (<) and right shift(>>) opérateurs. Il existe une fonction intégrée appelée bin() qui donne l’entier donné en représentation binaire. Pour illustrer les opérations au niveau du bit, nous l’utilisons lors de l’impression de la sortie dans l’exemple de code :

#!/usr/bin/python3
a = 54            # 54 = 0011 0110
b = 8            # 8 = 0000 1000
print ('a=',a,':',bin(a),'b=',b,':',bin(b))
c = 0
 
c = a & b;        # 0011 0110 AND 0000 1000 = 0000 0000 = 0
print ("result of AND is ", c,':',bin(c))
 
c = a | b;        # 0011 0110 OR 0000 1000 = 0011 1110 = 62 
print ("result of OR is ", c,':',bin(c))
 
c = a ^ b;        # 0011 0110 XOR 0000 1000 = 0011 1110 = 62
print ("result of EXOR is ", c,':',bin(c))
 
c = ~a;           # -55 = 1100 1001
print ("result of COMPLEMENT is ", c,':',bin(c))
 
c = a << 2;       # 216 = 1101 1000
print ("result of LEFT SHIFT is ", c,':',bin(c))
 
c = a >> 2;       # 13 = 0000 1101
print ("result of RIGHT SHIFT is ", c,':',bin(c))

La sortie du code ci-dessus sera :

a= 54 : 0b110110 b= 8 : 0b1000 le résultat de AND est 0 : 0b0 le résultat de OR est 62 : 0b111110 le résultat de EXOR est 62 : 0b111110 le résultat de COMPLEMENT est -55 : -0b110111 le résultat de LEFT SHIFT est 216 : 0b11011000 le résultat de SHIFT DROITE est 13 : 0b1101

Opérateurs d’adhésion

Dans et non dans sont les deux opérateurs d’appartenance. Ceux-ci sont utilisés pour savoir si une valeur donnée sur LHS est présente dans la construction de RHS.

#!/usr/bin/python3
firstTuple = ( 'Welcome', "To" , "List", 'Tutorial', 3.0  )
str1 = "Hello"
str2 = "Welcome"
if str1 in firstTuple:
    print(str1, " is present in firstTuple")
else:
    print(str1, " is NOT present in firstTuple")
if str2 in firstTuple:
    print(str2, " is present in firstTuple")
else:
    print(str2, " is NOT present in firstTuple")

La sortie du programme ci-dessus sera :

Hello n’est PAS présent dans firstTuple Welcome est présent dans firstTuple

Opérateurs d’identité

Est et n’est pas sont les opérateurs d’identité en Python. Ceux-ci sont utilisés pour vérifier si les variables sur LHS et RHS pointent vers le même objet en mémoire ou non.

#!/usr/bin/python3
 
var1 = 2
var2 = var1
var3 = 9
print(var1)
print(var2)
print(var3)
 
if(var1 is var2):
    print("var1 and var2 have same location")
else:
    print("var1 and var2 have different locations")
    
if(var3 is not var2):
    print("var3 and var2 have different locations")
else:
    print("var3 and var2 have same location")

La sortie du programme ci-dessus sera :

1397774624 1397774624 1397774736 var1 et var2 ont le même emplacement var3 et var2 ont des emplacements différents