Opérateurs en Python

Tout comme en mathématiques, les langages de programmation tels que Python disposent d'opérateurs. Vous pouvez les considérer comme des fonctions extrêmement simples qui sont à la base de l'informatique. Il s'agit des opérations les plus simples auxquelles un programme informatique peut être réduit. Il s'agit de connaissances essentielles pour tout scientifique de données ou ingénieur logiciel en herbe.

Dans ce tutoriel, vous apprendrez

• Les différents types d'opérateurs : Arithmétique, affectation, comparaison et logique
• Surcharge de l'opérateur
• Priorité
• L'associativité

Si vous souhaitez en savoir plus sur les bases du langage de programmation Python, ne manquez pas de consulter notre cours gratuit Intro to Python for Data Science.

Opérateurs arithmétiques

Vous les connaissez probablement déjà, puisqu'ils sont issus des mathématiques de base.

Les opérateurs arithmétiques sont l'addition (+), la soustraction (-), la multiplication (*), la division (/), l'exposant (**), la division plancher (//) et le module (%). Les quatre premières sont assez simples : il s'agit de l'addition, de la soustraction, de la multiplication et de la division, et vous les connaissez probablement déjà.

# Addition
print(5 + 2)

# Subtraction
print(5 - 2)

# Multiplication
print(5 * 2)

# Division
print(5 / 2)
Propulsé par

7
3
10
2.5
Propulsé par

Les trois autres sont un peu plus complexes. L'opérateur exposant signifie "élevé à la puissance de". Par exemple, 2 ** 3 signifie que 2 est multiplié par lui-même 3 fois, de sorte que 2 ** 3 est identique à 2 * 2 * 2, qui est égal à 8.

La division par étage est identique à la division normale, à ceci près que le résultat est toujours arrondi à la valeur inférieure. Dans l'exemple ci-dessous, 5 est divisé par 2, ce qui donne 2,5. Mais comme il s'agit de la division plancher, 2,5 est arrondi à 2.

Enfin, le module est le reste après la division. Dans le cas de 5%2, le chiffre 2 ne tient que deux fois dans 5, ce qui signifie que le reste est 1.

# Exponent
print(5 ** 2)
# This is the same as 5 * 5

# Floor Division
print(5 // 2)

# Modulus
print(5 % 2)
Propulsé par

25
2
1
Propulsé par

En Python, l'opérateur d'addition peut également être utilisé pour concaténer des chaînes de caractères. Cela signifie qu'ils seront assemblés en une seule chaîne, par exemple :

firstName = "Théo"

introduction = "Hi, my name is " + firstName + "."

print(introduction)
Propulsé par

Hi, my name is Théo.
Propulsé par

Opérateurs d'affectation

Si vous avez une certaine expérience de la programmation, vous avez certainement déjà utilisé des opérateurs d'affectation. Ils attribuent une certaine valeur à une variable. Le plus utilisé est =. Pour l'utiliser, il suffit de taper le nom de la variable à laquelle vous voulez attribuer une nouvelle valeur, le =, et la valeur que vous souhaitez voir attribuer. Par exemple, si vous souhaitez affecter la valeur 100 à la variable balance, vous pouvez procéder comme suit :

balance = 100
print(balance)
Propulsé par

100
Propulsé par

Si vous souhaitez incrémenter la valeur de balance de 10, vous pouvez utiliser balance += 10. C'est l'équivalent de balance = balance + 10, mais c'est beaucoup plus court.

balance += 10
print(balance)
Propulsé par

110
Propulsé par

Il en va de même pour -=, balance -= 10 est identique à balance = balance - 10:

print(balance)
balance -= 10
print(balance)
Propulsé par

110
100
Propulsé par

Les autres opérateurs d'affectation fonctionnent exactement de la même manière. Il s'agit de

• *=
• /=
• **=
• //=
• %=

Opérateurs de comparaison

Vous pouvez utiliser des opérateurs de comparaison pour, vous l'aurez deviné, comparer les valeurs des variables. Ils renvoient toujours une valeur booléenne, qui est soit True soit False. Ils sont au nombre de six :

• Égale : ==
• Pas d'égalité: !=
• Supérieur à : >
• Moins que : <
• Supérieur ou égal : >=
• Inférieur ou égal : <=

Voici quelques exemples de comparaisons :

a = 3
b = 5

print(a == b) # Equal
print(a != b) # Not equal
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to
Propulsé par

False
True
False
True
False
True
Propulsé par

== et != peuvent également être utilisés pour comparer des chaînes de caractères au lieu de nombres. Les autres opérateurs ne sont pas compatibles avec les chaînes de caractères, car une chaîne ne peut pas être plus grande qu'une autre chaîne.

print("Hello" == "World")
print("Python" != "R")
Propulsé par

False
True
Propulsé par

Opérateurs logiques

Vous les connaissez peut-être déjà ! En logique, ils sont appelés connecteurs logiques. Ils sont également largement utilisés dans le langage humain. Il s'agit de : and, or et not.

and ne renverra True que si les deux opérandes (les deux objets booléens que vous comparez) sont True. Par exemple :

print(True and True)
print(True and False)
print(False and False)
Propulsé par

True
False
False
Propulsé par

Pour comprendre le comportement de cet opérateur logique, vous pouvez utiliser un tableau de vérité :

or est Vrai, chaque fois qu'un (ou plusieurs) opérande est Vrai.

print(True and True)
print(True and False)
Propulsé par

True
False
Propulsé par

Notez qu' ils fonctionnent également avec plus de deux opérandes, par exemple :

print(True and True and True and True)
print(True and True and True and False)
print(False or False or False or False)
print(False or False or False or True)
Propulsé par

True
False
False
True
Propulsé par

not renvoie l'inverse de son opérande, donc True si False est donné et vice-versa.

print(not True)
Propulsé par

False
Propulsé par

Surcharge de l'opérateur

Rappelez-vous que vous avez vu précédemment comment + peut être utilisé pour additionner des nombres, mais qu'il peut également être utilisé pour concaténer, ou combiner des chaînes de caractères. Le site + fonctionne donc différemment selon le type d'objet sur lequel vous l'utilisez. Mais ce ne sera pas toujours le cas. Parfois, l'opérateur avec lequel vous travaillez ne prend tout simplement pas en charge le type d'objet sur lequel vous souhaitez l'utiliser.

En voici un exemple. Supposons que vous ayez deux objets Dog, ozzy et filou. Ils appartiennent à la classe Dog ci-dessous. Vous pouvez considérer la classe comme un plan de ce à quoi les objets doivent ressembler et comment ils doivent se comporter. Dans ce cas, les objets Dog ont un nom, un âge et une taille. Une fois la classe définie, vous pouvez instancier des objets. L'un d'entre eux est Ozzy, âgé de 3 ans et mesurant 30 centimètres. L'autre est Filou, il a 5 ans et mesure 65 centimètres.

Cet exemple utilise le concept de programmation orientée objet. Si vous souhaitez en savoir plus, lisez notre tutoriel sur la programmation orientée objet en Python.

Supposons que vous souhaitiez comparer les deux chiens à l'aide de la fonction plus grand que : >. Cela ne fonctionnera pas. Vous obtiendrez une erreur indiquant '>' not supported between instances of 'Dog' and 'Dog'. Cela signifie que > ne sait pas comment comparer les objets de la classe Dog.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
Propulsé par

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

TypeError                                 Traceback (most recent call last)

<ipython-input-96-428069ab24cc> in <module>()
      9 filou = Dog("Filou", 5, 65)
     10
---> 11 print(filou > ozzy)


TypeError: '>' not supported between instances of 'Dog' and 'Dog'
Propulsé par

Heureusement, avec la surcharge d'opérateur, vous pouvez définir le comportement de l'opérateur lorsqu'il est appelé sur des objets Dog. Dans ce cas, il convient de définir une méthode appelée __gt__, qui signifie "plus grand que", et qui prend en compte deux arguments. Puisque nous voulons comparer nos chiens sur leur taille, la méthode renvoie self.height > other.height.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

    def __gt__(self,other):
        return self.height > other.height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
print(ozzy > filou)
Propulsé par

True
False
Propulsé par

Priorité

Lorsque vous combinez plusieurs opérateurs, les choses peuvent devenir confuses. Regardez l'exemple ci-dessous :

a = 2
b = 3
c = 9

a ** b > 5 and c - a // b >= 9 or b ** 2 == c
Propulsé par

True
Propulsé par

Comment savoir lequel sera exécuté en premier ? Comment devez-vous lire une ligne de code contenant de nombreux symboles ? L'exécution se fait-elle de gauche à droite ou dans un ordre précis ?

C'est là qu'intervient la préséance. Les opérateurs Python sont exécutés dans un ordre bien précis, et certains ont la priorité sur d'autres.

Dans le tableau suivant, vous pouvez voir la préséance des opérateurs, dans l'ordre de haut en bas. Ces règles sont les mêmes en mathématiques, où certains calculs d'une formule doivent être effectués avant d'autres.

L'associativité

Vous avez pu constater que l'antériorité est importante ! Mais qu'en est-il de ceux qui sont au même niveau de priorité, comme la multiplication et la division ? Sont-ils exécutés en même temps ? No. *, \, % et \\ sont exécutés de gauche à droite, tandis que ** est exécuté de droite à gauche. C'est ce qu'on appelle l'associativité.

Regardez l'exemple suivant. Dans ce cas, les opérateurs sont exécutés de gauche à droite, et le résultat est 3.

print(5 * 2 // 3)
Propulsé par

3
Propulsé par

En ajoutant des parenthèses, vous pouvez toutefois modifier l'ordre d'exécution des opérateurs. Il s'agit de l'associativité, qui fonctionne de la même manière que l'associativité en mathématiques. Ce qui se trouve entre les crochets sera calculé en premier. Dans ce cas, la division de l'étage sera effectuée en premier, suivie de la multiplication.

print(5 * (2 // 3))
Propulsé par

Conclusion

Vous savez maintenant ce que sont les opérateurs, comment les utiliser et comment ils fonctionnent. Vous avez également appris ce que sont la surcharge, la précédence et l'associativité. Vous êtes en bonne voie pour devenir un maître de Python ! Si vous voulez en apprendre encore plus, n'hésitez pas à consulter notre cours Python intermédiaire pour la science des données.