Les opé­ra­teurs Python (Python Operators en anglais) vous per­met­tent de tra­vail­ler 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é­ra­teurs logiques ou arith­mé­tiques.

Opé­ra­teurs Python : qu’est-ce que c’est ? Comment fonc­tion­nent-ils ?

Un opérateur cor­res­pond au signe d’une opération. Les opé­ra­teurs sont souvent utilisés pour relier plusieurs opérandes. Cela permet gé­né­ra­le­ment 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é­ra­teurs Python, l’exemple le plus simple cor­res­pond à l’as­so­cia­tion de deux nombres grâce à un opérateur d’addition (soit le signe « + ») entre ceux-ci. Python évalue alors l’ex­pres­sion et restitue la valeur cor­res­pon­dante :

1 + 1

Python a pour par­ti­cu­la­rité d’utiliser, en plus des symboles, des mots courts tels que and, or, is, not ou in (lit­té­ra­le­ment « et, ou, est, pas, dans ») en tant qu’opé­ra­teurs. La com­bi­nai­son d’opé­ra­teurs et d’opérandes permet de créer une ex­pres­sion :

1 + 1 == 2

Quels sont les dif­fé­rents types d’opé­ra­teurs Python ?

Il existe plusieurs classes d’opé­ra­teurs Python. Ceux-ci fonc­tion­nent sur dif­fé­rentes sortes d’opérandes et donnent des résultats d’un type bien précis. Vous trouverez ci-dessous un aperçu des dif­fé­rentes sortes d’opé­ra­teurs Python :

Classe d’opé­ra­teurs Python Ex­pli­ca­tion Opérandes Résultat Pré­sen­ta­tion rapide des opé­ra­teurs
Opé­ra­teurs arith­mé­tiques Associent deux nombres pour en former un nouveau Nombres Nombre +, -, *, /, //, %, **, @
Opé­ra­teurs de com­pa­rai­son Comparent deux ex­pres­sions entre elles Ex­pres­sions Valeur booléenne <, >, ==, !=, <=, >=
Opé­ra­teurs logiques Associent des ex­pres­sions dans un contexte booléen Ex­pres­sions Dernière ex­pres­sion évaluée / valeur booléenne and, or, not (et, ou, pas)
Opé­ra­teurs bit à bit Ma­ni­pu­lent des nombres entiers en tant que suites binaires Nombres Nombre <<, >>, &, |, ^, ~
Opé­ra­teurs d’as­sig­na­tion Assignent une valeur à un nom Valeurs de gauche, valeurs de droite – / ex­pres­sion évaluée =, :=, +=, -=, *=, etc.
Opé­ra­teurs d’identité Dé­ter­mi­nent si deux noms font référence au même objet Objets Valeur booléenne is, is not (est, n’est pas)
Opé­ra­teurs con­di­tion­nels Se basent sur une condition pour renvoyer l’une des deux valeurs Ex­pres­sion, condition, al­ter­na­tive Ex­pres­sion / al­ter­na­tive … if… else… (… si… sinon…)
Opé­ra­teurs d’ensemble Associent deux ensembles ou comparent des ensembles Ensembles Ensemble / valeur booléenne &, |, ^, -, <, >, <=, >=
Opé­ra­teurs d’ap­par­te­nance Réalisent des tests pour savoir si une valeur itérative contient un objet spé­ci­fique Objet, valeur itérative Valeur booléenne in, not in (dans, pas dans)
Opé­ra­teurs de con­ca­té­na­tion Séquences con­ca­té­nées Chaînes de ca­rac­tères / listes / n-uplets Chaîne de ca­rac­tères / liste / n-uplet +
Opé­ra­teurs d’in­dexa­tion et de tranche Four­nis­sent un ou plusieurs éléments d’une valeur itérative Valeur itérative, index / tranche Chaîne de ca­rac­tères / liste / n-uplet [], [::]

En plus du type d’opérandes et de valeur de retour, le clas­se­ment des opé­ra­teurs 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é­ra­teurs « binaires », avec deux opérandes. Certains opé­ra­teurs 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é­ra­teurs

Pour utiliser les opé­ra­teurs Python, il est également essentiel de com­prendre leur ordre. En arith­mé­tique, ce concept est celui de la priorité des opé­ra­tions. Un petit rappel s’impose : l’ex­pres­sion 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’ap­pli­quent à tous les opé­ra­teurs Python. Voici un exemple d’ex­pres­sion utilisant les opé­ra­teurs logiques and, or et not :

if is_user and is_user_logged_in or is_admin and not login_blocked:
    …

Si vous ne con­nais­sez pas les règles de priorité ap­pli­cables aux opé­ra­teurs Python concernés, vous ne serez pas maître de la manière dont les dif­fé­rents termes s’associent entre eux. Cela peut vite s’avérer compliqué si vous utilisez plusieurs opé­ra­teurs dans une même ex­pres­sion. Nous vous re­com­man­dons gé­né­ra­le­ment de ne pas compter sur une com­pré­hen­sion parfaite de ces règles im­pli­cites, mais plutôt d’utiliser des pa­ren­thèses ex­pli­cites pour clarifier les liaisons exis­tantes entre les termes d’une même ex­pres­sion :

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

À titre de com­pa­rai­son, voici les mêmes termes regroupés de manière dif­fé­rente (l’énoncé n’est donc pas le même pour les deux ex­pres­sions) :

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

Dé­fi­ni­tion d’opérateur, méthodes Dunder et fonctions d’opé­ra­teurs Python

Certains opé­ra­teurs Python peuvent être utilisés pour plus d’une opération. À cet égard, le signe « + » est l’un des exemples les plus marquants ; il fonc­tionne en effet comme un opérateur d’addition pour les nombres, mais aussi comme un opérateur de con­ca­té­na­tion per­met­tant d’assembler des séquences telles que des chaînes ou des listes. Ici, nous ad­di­tion­nons deux nombres à l’aide de l’opérateur d’addition :

8 + 3 == 11

Avec ce même opérateur, nous con­ca­té­nons ensuite deux chaînes de ca­rac­tères :

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

L’opérateur « + » nous permet également de con­ca­té­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 in­for­ma­tique. Il est question de « dé­fi­ni­tion d’opérateur » lorsqu’un seul et même opérateur peut être utilisé pour dif­fé­rentes opé­ra­tions, suivant le type de données des opérandes.

Comment fonc­tionne la dé­fi­ni­tion d’opérateur avec Python ? L’opérateur et ses opérandes sont in­ter­pré­tés comme un appel de la fonction cor­res­pon­dante. 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 un­ders­core, « 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 ap­par­tient alors à l’objet de dé­ter­mi­ner la nature exacte de cette relation.

Outre les méthodes Dunder, le module de l’opérateur contient des fonctions qui ren­fer­ment les capacités des opé­ra­teurs Python. Ainsi, operator.add(a, b) permet d’appeler la méthode Dunder a.__add__(b), ce qui revient à l’ex­pres­sion 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 cor­res­pond au nom de la méthode Dunder qui y est associée. Nous vous con­seil­lons dès lors d’utiliser ces ré­fé­rences pour mettre en œuvre des fonc­tion­na­li­tés propres à vos opé­ra­teurs :

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

Les opé­ra­teurs font appel une notation infixe (c’est-à-dire qu’ils sont placés entre les opérandes). Le style fonc­tion­nel favorise toutefois la notation préfixe. Ces deux variantes sont néanmoins équi­va­lentes :

Notation Uti­li­sa­tion Exemple
Infixe Opé­ra­teurs a + b
Préfixe Fonctions + a b / add(a, b)

Con­si­dé­rons l’exemple suivant. Nous com­men­çons par définir deux nombres, que nous ad­di­tion­nons tous deux avec l’opérateur, la fonction de l’opérateur et la méthode Dunder cor­res­pon­dante :

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

Il est également possible d’élaborer des ex­pres­sions plus complexes à l’aide de ces fonctions. Vous pouvez voir ici un exemple de com­bi­nai­son des opé­ra­teurs Python « + » et « = » en notation préfixe :

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

Pré­sen­ta­tion rapide des opé­ra­teurs Python

Découvrez main­te­nant avec nous onze classes dif­fé­rentes d’opé­ra­teurs Python.

Opé­ra­teurs arith­mé­tiques

Les opé­ra­teurs arith­mé­tiques de Python fonc­tion­nent sur des nombres et servent à en générer un nouveau. À l’exception du « + » ou du « - » unaire, ces opé­ra­teurs sont toujours binaires. Retrouvez ci-dessous un aperçu :

Opérateur Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
+ Addition / « + » unaire add(a, b) / pos(a) 5 + 3 == 8 / +8 == 4 + 4
- Sous­trac­tion / « - » unaire sub(a, b) / neg(a) 7 - 2 == 5 / -4 == 2 - 6
* Mul­ti­pli­ca­tion 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
** Ex­po­nen­tia­tion 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é­ter­mi­ner 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 cor­res­pon­dante :

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

Le produit matriciel nécessite l’uti­li­sa­tion d’une bi­blio­thèque telle que NumPy.

Opé­ra­teurs de com­pa­rai­son Python

Les opé­ra­teurs de com­pa­rai­son 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’al­go­rithmes de tri :

Opérateur Python Sig­ni­fi­ca­tion 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é­ra­teurs logiques

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

Opérateur Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
and ET logique Aucune cor­res­pon­dance directe True and False == False, ’name’ and … == …
or OU logique Aucune cor­res­pon­dance 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é­ra­tions logiques sur des tables de vérité. Ici, c’est le « ET » logique qui est re­pré­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é­ra­teurs booléens de Python ne se limitent pas aux variables boo­léennes. Il est au contraire possible d’in­ter­pré­ter chaque objet Python dans un contexte booléen. Dans un contexte booléen, l’éva­lua­tion des objets suivants cor­res­pond à False (ce qui leur vaut donc l’ap­pel­la­tion falsy) :

Objet Ex­pli­ca­tion
False, None Cons­tantes qui sont, par dé­fi­ni­tion, fausses (False)
0, 0.0, Decimal(0), Fraction(0, 1), etc. Nombre re­pré­sen­tant une valeur nulle
’’, (), [], {}, set(), range(0), etc. Séquence ou col­lec­tion vide

Opé­ra­teurs bit à bit

Les opé­ra­teurs bit à bit de Python fonc­tion­nent à l’aide de nombres entiers in­ter­pré­tés comme des chaînes binaires. À l’exception de l’opérateur NOT, il s’agit toujours d’opé­ra­teurs bit à bit :

Opérateur Python Sig­ni­fi­ca­tion 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é­ra­teurs bit à bit sont parfaits pour optimiser les opé­ra­tions ma­thé­ma­tiques. Le décalage vers la gauche cor­res­pond donc à la mul­ti­pli­ca­tion par une puissance de deux :

Ex­pres­sion 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é­ra­tions AND, OR et NOT bit à bit, nous avons établi un tableau des dif­fé­rents bits. À l’aide d’un marquage, les opé­ra­tions sont ap­pli­quées à un nombre en re­pré­sen­ta­tion binaire :

Ex­pres­sion 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 de­vien­nent des 0, et in­ver­se­ment. Le signe du nombre est lui aussi inversé :

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

Opé­ra­teurs d’as­sig­na­tion

Les as­sig­na­tions comptent parmi les ins­truc­tions de base de la majorité des langages de pro­gram­ma­tion. Les opé­ra­teurs d’as­sig­na­tion de Python per­met­tent d’associer une valeur à un nom de variable. En plus de l’ins­truc­tion d’as­sig­na­tion, un opérateur « morse » plus récent peut être utilisé pour effectuer une as­sig­na­tion dans une ex­pres­sion. Vous pouvez également faire appel à une série d’ins­truc­tions d’as­sig­na­tion avancées combinant une as­sig­na­tion à une autre opération :

Opérateur Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
= Ins­truc­tion d’as­sig­na­tion Aucune cor­res­pon­dance directe name = ’Walther’
:= Ex­pres­sion d’as­sig­na­tion (opérateur « morse ») Aucune cor­res­pon­dance directe [ half for x in range(10) if (half := x / 2) < 5 ]
+= As­sig­na­tion d’addition avancée iadd(a, b) x = 1; x += 4; assert x == 5

Python propose des opé­ra­teurs d’as­sig­na­tion avancés pour les opé­ra­tions arith­mé­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 as­sig­na­tion de con­ca­té­na­tion avancée. Pour commencer, un élément est ajouté à une chaîne de ca­rac­tères existante à l’aide d’un code :

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

Voici un exemple similaire avec l’opérateur de con­ca­té­na­tion 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é­ra­teurs d’identité

L’opérateur is de Python effectue des tests visant à dé­ter­mi­ner si deux variables font référence au même objet dans la mémoire. L’identité d’objet est dif­fé­rente de l’égalité d’objet, testée quant à elle grâce à l’opérateur de com­pa­rai­son « == » de Python. L’opérateur is de Python cor­res­pond, à peu de choses près, à l’opérateur d’égalité rigoureux de Ja­vaS­cripts, « === ». Avec l’opérateur is not, Python permet également la réa­li­sa­tion de tests d’identité inversés.

Opérateur Python Sig­ni­fi­ca­tion 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]

In­té­res­sons-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 in­dé­pen­dants l’un de l’autre en mémoire. Ces objets sont certes iden­tiques, 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é­ra­teurs con­di­tion­nels

L’opérateur con­di­tion­nel de Python utilise encore dif­fé­rem­ment les mots-clés … if… else… Il sert le plus souvent à établir une dis­tinc­tion entre deux valeurs possibles en matière d’as­sig­na­tion. Étant donné que l’opérateur con­di­tion­nel associe une condition à deux ex­pres­sions, il est également qualifié d’opérateur « ternaire ».

Opérateur Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
… if… else… Ex­pres­sion con­di­tion­nelle Aucune cor­res­pon­dance directe name = ’Jim’ if age == 42 else ’Jack’

Com­men­çons par nous in­té­res­ser à un exemple utilisant l’ins­truc­tion … if… else… dans Python. Le code ci-dessous permet de définir les degrés Celsius ou Fah­ren­heit en tant qu’unité de ther­mo­mé­trie selon le système de mesure choisi :

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

L’uti­li­sa­tion de l’opérateur con­di­tion­nel permet de sim­pli­fier le code sous la forme d’une seule as­sig­na­tion :

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

Opé­ra­teurs d’ensemble Python

En plus des chaînes de ca­rac­tères, des n-uplets, des listes et des dic­tion­naires, les ensembles sont, par défaut, pris en charge par Python en tant que type de données composées. La dé­fi­ni­tion d’opérateur est alors utilisée pour les opé­ra­tions or­di­naires :

Opé­ra­teurs Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple    
& Créer une liaison entre deux ensembles and_(a, b) {’a’, ’b’} & {’a’, ’c’} == {’a’}    
    Créer une in­ter­sec­tion entre deux ensembles or_(a, b) {’a’, ’b’} {’a’, ’c’} == {’a’, ’c’, ’b’}
^ Créer une dif­fé­rence sy­mé­trique entre deux ensembles xor(a, b) {’a’, ’b’} ^ {’a’, ’c’} == {’c’, ’b’}    
- Créer une dif­fé­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é­ra­teurs d’ap­par­te­nance Python

Les opé­ra­teurs d’ap­par­te­nance in et not in de Python donnent des in­for­ma­tions sur la présence ou l’absence d’un objet dans une col­lec­tion.

Opérateur Python Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
in Test per­met­tant 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é­ra­teurs d’ap­par­te­nance fonc­tion­nent avec des valeurs ité­ra­tives et font appel à un dis­po­si­tif de vé­ri­fi­ca­tion de l’égalité visant à dé­ter­mi­ner si la col­lec­tion contient bien l’objet cible :

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

L’uti­li­sa­tion 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é­ra­teurs de con­ca­té­na­tion

L’opérateur de con­ca­té­na­tion 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 Sig­ni­fi­ca­tion Fonction de l’opérateur Exemple
+ Concatène deux séquences add(a, b) [’Jim’] + [’Jack’, ’John’]

In­té­res­sons-nous de plus près à quelques exemples. Nous allons ici con­ca­té­ner deux chaînes de ca­rac­tè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 pro­gram­ma­tion Web. Dans ce contexte, l’opérateur de con­ca­té­na­tion permet donc l’as­sem­blage de balises HTML :

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

Si vous comparez Python à PHP, vous vous rendrez compte qu’il existe des dif­fé­rences entre les opé­ra­teurs de con­ca­té­na­tion 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é­ra­teurs d’in­dexa­tion et de tranche

L’opérateur d’in­dexa­tion de Python permet d’extraire d’une col­lec­tion un élément spé­ci­fique. L’opérateur de tranche sert quant à lui à en extraire une sous-séquence.

Opérateur Python Sig­ni­fi­ca­tion 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é­ra­teurs d’in­dexa­tion 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é­ces­saire d’utiliser une boucle for Python ou une boucle while Python. Les personnes res­pon­sables de la pro­gram­ma­tion 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]
Aller au menu principal