# 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 : ```none 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 : ```none 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* : ```none 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 : ```none 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) : ```none 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 : ```none 8 + 3 == 11 ``` Avec ce même opérateur, nous concaténons ensuite **deux chaînes de caractères** : ```none "Walter" + "White" == "WalterWhite" ``` L’opérateur « + » nous permet également de concaténer les **listes** : ```none [’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](https://docs.python.org/3/library/operator.html "Opérateurs standard en tant que fonctions : documentation Python 3.10.4") 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 : ```none 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 : ```none 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 : ```none 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 : ```none 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 : ```none 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*. ```none # 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* : ```none # 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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-if-else/). 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 : ```none 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 : ```none 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 : ```none ’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 : ```none 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** : ```none 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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/langages-de-programmation-web/ "Langages de programmation Web"). Dans ce contexte, l’opérateur de concaténation permet donc l’assemblage de [balises HTML](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/balises-htlm/) : ```none site_title = ’Welcome’ print(’

’ + site_title + ’

’) ``` Si vous comparez [Python à PHP](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/php-vs-python/), 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** : ```none $siteTitle = ’Welcome’; echo ’

’ . $siteTitle . ’

’; ``` ### 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 : ```none 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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/loop-for-en-python/) ou une [boucle while Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/boucle-while-en-python/). Les personnes responsables de la programmation n’ont donc plus à écrire leur code sous cette forme : ```none 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] ``` This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-python/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/operateurs-python/) for AI/LLM consumption.