Python Operators : présentation rapide des opérateurs Python 

Les opérateurs Python (Python Operators en anglais) vous permettent de travailler avec des valeurs (ou opérandes), de les modifier ou de les relier les unes aux autres. Il peut par exemple s’agir d’opérateurs logiques ou arithmétiques.

Opérateurs Python : qu’est-ce que c’est ? Comment fonctionnent-ils ?

Un opérateur correspond au signe d’une opération. Les opérateurs sont souvent utilisés pour relier plusieurs opérandes. Cela permet généralement de créer une nouvelle valeur. Si vous appliquez un opérateur à un seul opérande, vous modifiez celui-ci.

Dans le cas des opérateurs Python, l’exemple le plus simple correspond à l’association de deux nombres grâce à un opérateur d’addition (soit le signe « + ») entre ceux-ci. Python évalue alors l’expression et restitue la valeur correspondante :

1 + 1

Python a pour particularité d’utiliser, en plus des symboles, des mots courts tels que and, or, is, not ou in (littéralement « et, ou, est, pas, dans ») en tant qu’opérateurs. La combinaison d’opérateurs et d’opérandes permet de créer une expression :

1 + 1 == 2

Quels sont les différents types d’opérateurs Python ?

Il existe plusieurs classes d’opérateurs Python. Ceux-ci fonctionnent sur différentes sortes d’opérandes et donnent des résultats d’un type bien précis. Vous trouverez ci-dessous un aperçu des différentes sortes d’opérateurs Python :

Classe d’opérateurs Python Explication Opérandes Résultat Présentation rapide des opérateurs
Opérateurs arithmétiques Associent deux nombres pour en former un nouveau Nombres Nombre +, -, *, /, //, %, **, @
Opérateurs de comparaison Comparent deux expressions entre elles Expressions Valeur booléenne <, >, ==, !=, <=, >=
Opérateurs logiques Associent des expressions dans un contexte booléen Expressions Dernière expression évaluée / valeur booléenne and, or, not (et, ou, pas)
Opérateurs bit à bit Manipulent des nombres entiers en tant que suites binaires Nombres Nombre <<, >>, &, |, ^, ~
Opérateurs d’assignation Assignent une valeur à un nom Valeurs de gauche, valeurs de droite – / expression évaluée =, :=, +=, -=, *=, etc.
Opérateurs d’identité Déterminent si deux noms font référence au même objet Objets Valeur booléenne is, is not (est, n’est pas)
Opérateurs conditionnels Se basent sur une condition pour renvoyer l’une des deux valeurs Expression, condition, alternative Expression / alternative … if… else… (… si… sinon…)
Opérateurs d’ensemble Associent deux ensembles ou comparent des ensembles Ensembles Ensemble / valeur booléenne &, |, ^, -, <, >, <=, >=
Opérateurs d’appartenance Réalisent des tests pour savoir si une valeur itérative contient un objet spécifique Objet, valeur itérative Valeur booléenne in, not in (dans, pas dans)
Opérateurs de concaténation Séquences concaténées Chaînes de caractères / listes / n-uplets Chaîne de caractères / liste / n-uplet +
Opérateurs d’indexation et de tranche Fournissent un ou plusieurs éléments d’une valeur itérative Valeur itérative, index / tranche Chaîne de caractères / liste / n-uplet [], [::]

En plus du type d’opérandes et de valeur de retour, le classement des opérateurs prend également en compte leur « arité ». L’arité d’un opérateur n’a rien à voir avec la « parité ». Ce terme désigne plutôt le nombre d’opérandes associés par un opérateur. La plupart du temps, il s’agit d’opérateurs « binaires », avec deux opérandes. Certains opérateurs sont également dits « unaires » (avec un seul opérande) ou « ternaires » (qui associe trois opérandes) :

Arité de l’opérateur Nombre d’opérandes Exemple
Unaire Un opérande not single_value
Binaire Deux opérandes left_operand + right_operand
Ternaire Trois opérandes some_value if condition else other_value

Tenir compte de l’ordre des opérateurs

Pour utiliser les opérateurs Python, il est également essentiel de comprendre leur ordre. En arithmétique, ce concept est celui de la priorité des opérations. Un petit rappel s’impose : l’expression 3 * 8 + 2 doit être traitée sous la forme (3 * 8) + 2, et non sous la forme 3 * (8 + 2). Comme pour les signes « + » et « * » utilisés ci-dessus, des règles de priorité s’appliquent à tous les opérateurs Python. Voici un exemple d’expression utilisant les opérateurs logiques and, or et not :

if is_user and is_user_logged_in or is_admin and not login_blocked:
    …

Si vous ne connaissez pas les règles de priorité applicables aux opérateurs Python concernés, vous ne serez pas maître de la manière dont les différents termes s’associent entre eux. Cela peut vite s’avérer compliqué si vous utilisez plusieurs opérateurs dans une même expression. Nous vous recommandons généralement de ne pas compter sur une compréhension parfaite de ces règles implicites, mais plutôt d’utiliser des parenthèses explicites pour clarifier les liaisons existantes entre les termes d’une même expression :

if (is_user and is_user_logged_in) or (is_admin and not login_blocked):
    …

À titre de comparaison, voici les mêmes termes regroupés de manière différente (l’énoncé n’est donc pas le même pour les deux expressions) :

if (is_user and is_user_logged_in or is_admin) and not login_blocked:
    …

Définition d’opérateur, méthodes Dunder et fonctions d’opérateurs Python

Certains opérateurs Python peuvent être utilisés pour plus d’une opération. À cet égard, le signe « + » est l’un des exemples les plus marquants ; il fonctionne en effet comme un opérateur d’addition pour les nombres, mais aussi comme un opérateur de concaténation permettant d’assembler des séquences telles que des chaînes ou des listes. Ici, nous additionnons deux nombres à l’aide de l’opérateur d’addition :

8 + 3 == 11

Avec ce même opérateur, nous concaténons ensuite deux chaînes de caractères :

"Walter" + "White" == "WalterWhite"

L’opérateur « + » nous permet également de concaténer les listes :

[’Jack’, ’Jim’] + [’John’] == [’Jack’, ’Jim’, ’John’]

Ce « double emploi » du signe « + » en tant qu’opérateur s’apparente à un concept plutôt répandu en informatique. Il est question de « définition d’opérateur » lorsqu’un seul et même opérateur peut être utilisé pour différentes opérations, suivant le type de données des opérandes.

Comment fonctionne la définition d’opérateur avec Python ? L’opérateur et ses opérandes sont interprétés comme un appel de la fonction correspondante. Une « méthode Dunder » est appelée au niveau du premier opérande, qui reçoit le ou les opérandes suivants comme des arguments. Le mot « Dunder » vient de l’anglais double underscore, « double tiret du bas ». L’opérateur « + » est le reflet de la méthode Dunder __add__(). Les objets mettant en œuvre une méthode __add__() peuvent être associés à l’opérateur « + ». Il appartient alors à l’objet de déterminer la nature exacte de cette relation.

Outre les méthodes Dunder, le module de l’opérateur contient des fonctions qui renferment les capacités des opérateurs Python. Ainsi, operator.add(a, b) permet d’appeler la méthode Dunder a.__add__(b), ce qui revient à l’expression a + b. Découvrez avec nous la fonction de chaque opérateur, dans la mesure où celui-ci en a une. Le nom de la fonction de l’opérateur correspond au nom de la méthode Dunder qui y est associée. Nous vous conseillons dès lors d’utiliser ces références pour mettre en œuvre des fonctionnalités propres à vos opérateurs :

Opérateur Python Fonction de l’opérateur Méthode Dunder
a + b operator.add(a, b) a.__add__(b)

Les opérateurs font appel une notation infixe (c’est-à-dire qu’ils sont placés entre les opérandes). Le style fonctionnel favorise toutefois la notation préfixe. Ces deux variantes sont néanmoins équivalentes :

Notation Utilisation Exemple
Infixe Opérateurs a + b
Préfixe Fonctions + a b / add(a, b)

Considérons l’exemple suivant. Nous commençons par définir deux nombres, que nous additionnons tous deux avec l’opérateur, la fonction de l’opérateur et la méthode Dunder correspondante :

import operator
a = 42
b = 69
assert a + b == operator.add(a, b) == a.__add__(b)

Il est également possible d’élaborer des expressions plus complexes à l’aide de ces fonctions. Vous pouvez voir ici un exemple de combinaison des opérateurs Python « + » et « = » en notation préfixe :

import operator
assert ’Py’ + ’thon’ == ’Python’
assert operator.eq(operator.add(’Py’, ’thon’), ’Python’)

Présentation rapide des opérateurs Python

Découvrez maintenant avec nous onze classes différentes d’opérateurs Python.

Opérateurs arithmétiques

Les opérateurs arithmétiques de Python fonctionnent sur des nombres et servent à en générer un nouveau. À l’exception du « + » ou du « - » unaire, ces opérateurs sont toujours binaires. Retrouvez ci-dessous un aperçu :

Opérateur Python Signification Fonction de l’opérateur Exemple
+ Addition / « + » unaire add(a, b) / pos(a) 5 + 3 == 8 / +8 == 4 + 4
- Soustraction / « - » unaire sub(a, b) / neg(a) 7 - 2 == 5 / -4 == 2 - 6
* Multiplication mul(a, b) 2 * 3 == 6
/ « Véritable » division truediv(a, b) 8 / 2 == 4.0, 7 / 2 == 3.5
// Division de nombres entiers par le plus petit nombre entier suivant floordiv(a, b) 8 // 2 == 4, 7 // 2 == 3
% Opération modulo : reste de la division de nombres entiers mod(a, b) 8 % 2 == 0, 7 % 2 == 1
** Exponentiation pow(a, b) 2 ** 3 == 8, 10 ** -1 == 0.1
@ Produit matriciel matmul(a, b) –

Par défaut, l’opération modulo est utilisée pour déterminer si un nombre est pair ; le reste d’un nombre pair divisé par deux est en effet toujours nul. L’opérateur modulo nous permet de définir la fonction Python correspondante :

def is_even(number):
    return number % 2 == 0
# test
assert is_even(8) and not is_even(7)

Le produit matriciel nécessite l’utilisation d’une bibliothèque telle que NumPy.

Opérateurs de comparaison Python

Les opérateurs de comparaison de Python vous indiquent la manière dont deux éléments peuvent être organisés entre eux. Ils renvoient un résultat booléen et peuvent notamment être utilisés dans le cadre d’algorithmes de tri :

Opérateur Python Signification Fonction de l’opérateur Exemple
< Inférieur à lt(a, b) 3 < 1, ’a’ < ’z’
> Supérieur à gt(a, b) 4 > 2, ’z’ > ’a’
== Égal à eq(a, b) ’a’ == ’a’
!= Différent de ne(a, b) 1 != 2, ’Jim’ != ’Jack’
<= Inférieur ou égal à le(a, b) 9 <= 10, 10 <= 10
>= Supérieur ou égal à ge(a, b) 11 >= 10, 10 >= 10

Opérateurs logiques

Les opérateurs logiques and et or de Python connectent plusieurs opérandes en suivant une logique booléenne. Pour ce qui est du résultat, chacun des deux opérateurs renvoie le dernier objet qu’il a évalué. L’opérateur logique not de Python permet quant à lui d’interpréter un objet dans un contexte booléen et d’inverser sa valeur logique :

Opérateur Python Signification Fonction de l’opérateur Exemple
and ET logique Aucune correspondance directe True and False == False, ’name’ and … == …
or OU logique Aucune correspondance directe False or True == True, a = ’’ or ’Default’; assert a == ’Default’
not Négation not_(a) not True == False

Il peut s’avérer utile de démontrer l’effet des opérations logiques sur des tables de vérité. Ici, c’est le « ET » logique qui est représenté :

and True False
True True False
False False False

C’est aussi le cas du « OU » logique :

or True False
True True True
False True False

Les opérandes des opérateurs booléens de Python ne se limitent pas aux variables booléennes. Il est au contraire possible d’interpréter chaque objet Python dans un contexte booléen. Dans un contexte booléen, l’évaluation des objets suivants correspond à False (ce qui leur vaut donc l’appellation falsy) :

Objet Explication
False, None Constantes qui sont, par définition, fausses (False)
0, 0.0, Decimal(0), Fraction(0, 1), etc. Nombre représentant une valeur nulle
’’, (), [], {}, set(), range(0), etc. Séquence ou collection vide

Opérateurs bit à bit

Les opérateurs bit à bit de Python fonctionnent à l’aide de nombres entiers interprétés comme des chaînes binaires. À l’exception de l’opérateur NOT, il s’agit toujours d’opérateurs bit à bit :

Opérateur Python Signification Fonction de l’opérateur Exemple
<< Déplacer la chaîne binaire vers la gauche lshift(a, b) 5 << 3 == 5 * 2 ** 3
>> Déplacer la chaîne binaire vers la droite rshift(a, b) 1 >> 1 == 0, 8 >> 1 == 4
& Associer deux chaînes binaires à l’aide de l’opérateur AND and_(a, b) ``
| Associer deux chaînes binaires à l’aide de l’opérateur « OR » or_(a, b) ``
^ Associer deux chaînes binaires à l’aide de l’opérateur « XOR » xor(a, b) ``
~ Inverser la chaîne binaire avec l’opérateur NOT invert(a) ``

Les opérateurs bit à bit sont parfaits pour optimiser les opérations mathématiques. Le décalage vers la gauche correspond donc à la multiplication par une puissance de deux :

Expression 23 = 8 22 = 4 21 = 2 20 = 1 Décimale
b = 6 0 1). 1). 0 6
b << 1 1). 1). 0 0 12
b >> 1 0 0 1). 1). 3

Afin d’illustrer les opérations AND, OR et NOT bit à bit, nous avons établi un tableau des différents bits. À l’aide d’un marquage, les opérations sont appliquées à un nombre en représentation binaire :

Expression 23 = 8 22 = 4 21 = 2 20 = 1 Décimale
bits = 6 0 1). 1). 0 6
mask = 5 0 1). 0 1). 5
bits & mask 0 1). 0 0 4
bits | masquage 0 1). 1). 1). 7
bits ^ mask 0 0 1). 1). 3

L’opérateur bit à bit de Python NOT permet d’inverser une chaîne de bits. Tous les 1 deviennent des 0, et inversement. Le signe du nombre est lui aussi inversé :

Expression 23 = 8 22 = 4 21 = 2 20 = 1 Décimale
b = 6 0 1). 1). 0 6
~ b 1). 0 0 1). -7

Opérateurs d’assignation

Les assignations comptent parmi les instructions de base de la majorité des langages de programmation. Les opérateurs d’assignation de Python permettent d’associer une valeur à un nom de variable. En plus de l’instruction d’assignation, un opérateur « morse » plus récent peut être utilisé pour effectuer une assignation dans une expression. Vous pouvez également faire appel à une série d’instructions d’assignation avancées combinant une assignation à une autre opération :

Opérateur Python Signification Fonction de l’opérateur Exemple
= Instruction d’assignation Aucune correspondance directe name = ’Walther’
:= Expression d’assignation (opérateur « morse ») Aucune correspondance directe [ half for x in range(10) if (half := x / 2) < 5 ]
+= Assignation d’addition avancée iadd(a, b) x = 1; x += 4; assert x == 5

Python propose des opérateurs d’assignation avancés pour les opérations arithmétiques et bit à bit. La liste complète n’apparaît pas dans cet article, mais vous pouvez découvrir leur modèle général ci-dessous, illustré par une assignation de concaténation avancée. Pour commencer, un élément est ajouté à une chaîne de caractères existante à l’aide d’un code :

name = ’Walther’
name = name + ’White’
assert name == ’WaltherWhite’

Voici un exemple similaire avec l’opérateur de concaténation avancée « += » de Python. Si cela conduit au même résultat, le code est ici plus concis et pertinent :

name  = ’Walther’
name += ’White’
assert name == ’WaltherWhite’

Opérateurs d’identité

L’opérateur is de Python effectue des tests visant à déterminer si deux variables font référence au même objet dans la mémoire. L’identité d’objet est différente de l’égalité d’objet, testée quant à elle grâce à l’opérateur de comparaison « == » de Python. L’opérateur is de Python correspond, à peu de choses près, à l’opérateur d’égalité rigoureux de JavaScripts, « === ». Avec l’opérateur is not, Python permet également la réalisation de tests d’identité inversés.

Opérateur Python Signification Fonction de l’opérateur Exemple
is Test d’identité is_(a, b) a = 42; b = a; assert a is b
is not Test d’identité inversé is_not(a, b) assert [42] is not [42]

Intéressons-nous de plus près à quelques exemples. Nous allons pour cela créer une référence à un objet en mémoire, suivie plus tard d’une autre référence (sous forme d’alias). Si les deux variables font bien référence au même objet en mémoire, l’opérateur is renvoie le résultat True.

# assign value to name
a = [42]
# reference existing object
b = a
# if this holds
assert a is b
# so will this
assert a == b

Nous allons ici créer deux références à des objets indépendants l’un de l’autre en mémoire. Ces objets sont certes identiques, mais ils restent néanmoins distincts. L’opérateur is renvoie alors le résultat False :

# assign the same value to different names
a = [42]
b = [42]
# `a`, `b` are two different objects
assert a is not b
# that contain the same value
assert a == b

Opérateurs conditionnels

L’opérateur conditionnel de Python utilise encore différemment les mots-clés … if… else… Il sert le plus souvent à établir une distinction entre deux valeurs possibles en matière d’assignation. Étant donné que l’opérateur conditionnel associe une condition à deux expressions, il est également qualifié d’opérateur « ternaire ».

Opérateur Python Signification Fonction de l’opérateur Exemple
… if… else… Expression conditionnelle Aucune correspondance directe name = ’Jim’ if age == 42 else ’Jack’

Commençons par nous intéresser à un exemple utilisant l’instruction … if… else… dans Python. Le code ci-dessous permet de définir les degrés Celsius ou Fahrenheit en tant qu’unité de thermométrie selon le système de mesure choisi :

if system == ’metric’:
    unit = ’C’
else:
    unit = ’F’

L’utilisation de l’opérateur conditionnel permet de simplifier le code sous la forme d’une seule assignation :

unit = ’C’ if system == ’metric’ else ’F’

Opérateurs d’ensemble Python

En plus des chaînes de caractères, des n-uplets, des listes et des dictionnaires, les ensembles sont, par défaut, pris en charge par Python en tant que type de données composées. La définition d’opérateur est alors utilisée pour les opérations ordinaires :

Opérateurs Python Signification Fonction de l’opérateur Exemple    
& Créer une liaison entre deux ensembles and_(a, b) {’a’, ’b’} & {’a’, ’c’} == {’a’}    
    Créer une intersection entre deux ensembles or_(a, b) {’a’, ’b’} {’a’, ’c’} == {’a’, ’c’, ’b’}
^ Créer une différence symétrique entre deux ensembles xor(a, b) {’a’, ’b’} ^ {’a’, ’c’} == {’c’, ’b’}    
- Créer une différence entre deux ensembles sub(a, b) {’a’, ’b’} - {’a’} == {’b’}    
> Vérifier s’il s’agit d’un véritable sur-ensemble gt(a, b) assert {’a’, ’b’} > {’a’}    
>= Vérifier s’il s’agit d’un sur-ensemble ge(a, b) assert {’a’} >= {’a’}    
< Vérifier s’il s’agit d’un véritable sous-ensemble lt(a, b) assert {’a’} < {’a’, ’b’}    
<= Vérifier s’il s’agit d’un sous-ensemble le(a, b) assert {’a’} <= {’a’}    

Opérateurs d’appartenance Python

Les opérateurs d’appartenance in et not in de Python donnent des informations sur la présence ou l’absence d’un objet dans une collection.

Opérateur Python Signification Fonction de l’opérateur Exemple
in Test permettant de vérifier si un objet est contenu dans une valeur itérative contains(a, b) ’y’ in ’Python’
not in Inversion de l’opérateur in not contains(a, b) ’x’ not in ’Python’

Les opérateurs d’appartenance fonctionnent avec des valeurs itératives et font appel à un dispositif de vérification de l’égalité visant à déterminer si la collection contient bien l’objet cible :

’Py’ in ’Python’
’Px’ not in ’Python’
’Jack’ in [’Jim’, ’Jack’]

L’utilisation de l’opérateur in évite d’avoir à écrire du code sous la forme suivante :

def my_in(target, collection):
    for element in collection:
        if element == target:
            return True
    return False
# test
word = ’Python’
letter = ’y’
assert (my_in(letter, word)) == (letter in word)

Opérateurs de concaténation

L’opérateur de concaténation de Python permet de relier entre elles plusieurs séquences de même type. L’opérateur a pour symbole le signe « + ».

Opérateur Python Signification Fonction de l’opérateur Exemple
+ Concatène deux séquences add(a, b) [’Jim’] + [’Jack’, ’John’]

Intéressons-nous de plus près à quelques exemples. Nous allons ici concaténer deux chaînes de caractères, deux listes et deux n-uplets :

assert "Walter" + "White" == ’WalterWhite’
assert [’a’, ’b’] + [’c’] == [’a’, ’b’, ’c’]
assert (’q’, ’r’) + (’s’, ’t’) == (’q’, ’r’, ’s’, ’t’)

Python est utilisé comme un langage de programmation Web. Dans ce contexte, l’opérateur de concaténation permet donc l’assemblage de balises HTML :

site_title = ’Welcome’
print(’<h1>’ + site_title + ’</h1>’)

Si vous comparez Python à PHP, vous vous rendrez compte qu’il existe des différences entre les opérateurs de concaténation des deux langages. PHP utilise en effet le symbole « . ». Voici le même exemple, utilisant cette fois-ci le langage PHP :

$siteTitle = ’Welcome’;
echo ’<h1>’ . $siteTitle . ’</h1>’;

Opérateurs d’indexation et de tranche

L’opérateur d’indexation de Python permet d’extraire d’une collection un élément spécifique. L’opérateur de tranche sert quant à lui à en extraire une sous-séquence.

Opérateur Python Signification Fonction de l’opérateur Exemple
iterable[index] Renvoie l’élément d’une valeur itérative située au niveau de l’index getitem(iterable, index) ’Python’[1] == ’y’
sequence[start:stop:step] Renvoie une tranche de la séquence concernée getitem(iterable, slice(start, stop, step)) ’Python’[0:1] == ’Py’, ’Python’[0:-1:2] == ’Pto’

En interne, les opérateurs d’indexation et de tranche de Python font appel à la méthode Dunder __getitem__(). Celle-ci est alors appelée à partir d’un index numérique ou d’un objet de tranche :

names = [’Jim’, ’Jack’, ’John’]
names[0] == names.__getitem__(0)
names[0:2] == names.__getitem__(slice(0, 2))

Si l’opérateur de tranche est pratique, c’est parce qu’il permet d’extraire une sous-séquence sans qu’il soit pour autant nécessaire d’utiliser une boucle for Python ou une boucle while Python. Les personnes responsables de la programmation n’ont donc plus à écrire leur code sous cette forme :

word = ’Python’
start, stop, step = 0, 5, 2
index, substring = start, ’’
while index in range(start, stop, step):
    substring += word[index]
    index += step
# test
assert substring == word[start:stop:step]
Cet article vous a-t-il été utile ?