Opérateurs de base de Python

Opérateurs de base de Python

Les opérateurs sont des symboles ou des mots-clés spéciaux en Python qui effectuent des opérations sur des valeurs. Ces valeurs sont appelées opérandes.

Par exemple, dans l’expression 4 + 5, le + est l’opérateur, et 4 et 5 sont les opérandes. L’expression s’évalue à 9.

Types d’opérateurs

Python prend en charge plusieurs types d’opérateurs :

• Opérateurs arithmétiques
• Opérateurs de comparaison (relationnels)
• Opérateurs d’affectation
• Opérateurs logiques
• Opérateurs binaires (Bitwise)
• Opérateurs d’appartenance
• Opérateurs d’identité

Explorons chaque type.

Opérateurs arithmétiques de Python

Ces opérateurs effectuent des calculs mathématiques standard. Supposons a = 10 et b = 20.

Opérateur	Description	Exemple (a=10, b=20)
+ Addition	Ajoute les valeurs des opérandes.	a + b donne 30
- Soustraction	Soustrait l’opérande droit de l’opérande gauche.	a - b donne -10
* Multiplication	Multiplie les valeurs des opérandes.	a * b donne 200
/ Division	Divise l’opérande gauche par l’opérande droit. Le résultat est toujours un flottant.	b / a donne 2.0
% Modulo	Renvoie le reste de la division.	b % a donne 0. 13 % a donne 3.
** Exponentiation	Élève l’opérande gauche à la puissance de l’opérande droit.	a ** 2 donne 100 (10 puissance 2)
// Division entière	Divise et arrondit le résultat vers le bas au nombre entier le plus proche.	9 // 2 donne 4. 9.0 // 2.0 donne 4.0.

Opérateurs de comparaison de Python

Ces opérateurs comparent deux valeurs et renvoient un résultat booléen (True ou False). Ils sont également connus sous le nom d’opérateurs relationnels. Supposons a = 10 et b = 20.

Opérateur	Description	Exemple (a=10, b=20)
== Égal à	Renvoie True si les deux opérandes sont égaux.	a == b est False. a == 10 est True.
!= Non égal à	Renvoie True si les opérandes ne sont pas égaux.	a != b est True. a != 10 est False.
> Supérieur à	Renvoie True si l’opérande gauche est supérieur à l’opérande droit.	a > b est False.
< Inférieur à	Renvoie True si l’opérande gauche est inférieur à l’opérande droit.	a < b est True.
>= Supérieur ou égal à	Renvoie True si l’opérande gauche est supérieur ou égal à l’opérande droit.	a >= b est False. a >= 10 est True.
<= Inférieur ou égal à	Renvoie True si l’opérande gauche est inférieur ou égal à l’opérande droit.	a <= b est True. a <= 10 est True.

Note : L’opérateur <> est obsolète en Python 3 ; utilisez != à la place.

Opérateurs d’affectation de Python

Ces opérateurs affectent des valeurs aux variables, combinant souvent une opération arithmétique avec une affectation. Supposons a = 10, b = 20 et c = 0 initialement.

Opérateur	Description	Exemple (a=10)
= Affecter	Affecte la valeur de l’opérande droit à l’opérande gauche.	c = a + b affecte 30 à c.
+= Ajouter ET	Ajoute l’opérande droit à l’opérande gauche et affecte le résultat à l’opérande gauche.	c += a est équivalent à c = c + a. Si c était 0, c devient 10.
-= Soustraire ET	Soustrait l’opérande droit de l’opérande gauche et affecte le résultat à l’opérande gauche.	c -= a est équivalent à c = c - a.
*= Multiplier ET	Multiplie l’opérande gauche par l’opérande droit et affecte le résultat à l’opérande gauche.	c *= a est équivalent à c = c * a.
/= Diviser ET	Divise l’opérande gauche par l’opérande droit et affecte le résultat (flottant) à l’opérande gauche.	c /= a est équivalent à c = c / a.
%= Modulo ET	Prend le modulo et affecte le résultat à l’opérande gauche.	c %= a est équivalent à c = c % a.
**= Exposant ET	Élève l’opérande gauche à la puissance de l’opérande droit et affecte le résultat à l’opérande gauche.	c **= a est équivalent à c = c ** a.
//= Division entière ET	Effectue la division entière (floor division) et affecte le résultat à l’opérande gauche.	c //= a est équivalent à c = c // a.

Opérateurs binaires de Python

Les opérateurs binaires agissent sur les opérandes comme des séquences de chiffres binaires (bits). Ils sont souvent utilisés pour des manipulations de bas niveau ou des optimisations. Supposons a = 60 et b = 13.

Représentations binaires :

`a = 60  -> 0011 1100`
`b = 13  -> 0000 1101`

Opérateur	Description	Exemple (a=60, b=13)
& ET binaire	Met chaque bit à 1 si les deux bits correspondants sont à 1.	a & b donne 12 (0000 1100)
| OU binaire	Met chaque bit à 1 si au moins un des bits correspondants est à 1.	a | b donne 61 (0011 1101)
^ OU exclusif binaire	Met chaque bit à 1 si un seul des bits correspondants est à 1.	a ^ b donne 49 (0011 0001)
~ NON binaire (Complément)	Inverse tous les bits (0 devient 1, 1 devient 0). Appliqué à un seul opérande. Le résultat dépend de la représentation numérique (par exemple, complément à deux pour les entiers signés).	~a donne -61. Le résultat est -(a + 1) pour les entiers positifs dans les systèmes typiques de complément à deux.
<< Décalage à gauche	Décale les bits de l’opérande gauche vers la gauche du nombre de positions spécifié par l’opérande droit. Remplit avec des zéros à droite.	a << 2 donne 240 (1111 0000)
>> Décalage à droite	Décale les bits de l’opérande gauche vers la droite du nombre de positions spécifié par l’opérande droit. Remplit avec le bit de signe à gauche (décalage arithmétique) ou des zéros (décalage logique - Python effectue un décalage arithmétique).	a >> 2 donne 15 (0000 1111)

Opérateurs logiques de Python

Ces opérateurs combinent des expressions conditionnelles. Supposons x = True et y = False.

Opérateur	Description	Exemple (x=True, y=False)
and ET logique	Renvoie True si les deux opérandes sont vrais.	x and y est False.
or OU logique	Renvoie True si au moins un opérande est vrai.	x or y est True.
not NON logique	Renvoie True si l’opérande est faux, et False si l’opérande est vrai.	not x est False. not y est True.

Opérateurs d’appartenance de Python

Ces opérateurs vérifient si une séquence (comme une chaîne, une liste, un tuple, un ensemble, des clés de dictionnaire) contient un élément spécifique. Supposons my_list = [1, 2, 3].

Opérateur	Description	Exemple (my_list=[1, 2, 3])
in	Renvoie True si la valeur/variable est trouvée dans la séquence.	2 in my_list est True.
not in	Renvoie True si la valeur/variable n’est pas trouvée dans la séquence.	4 not in my_list est True.

Opérateurs d’identité de Python

Ces opérateurs comparent les emplacements mémoire de deux objets, vérifiant s’ils font référence à la même instance d’objet. Supposons x = [1, 2], y = [1, 2] et z = x.

Opérateur	Description	Exemple (x=[1,2], y=[1,2], z=x)
is	Renvoie True si les deux variables pointent vers le même objet en mémoire.	x is z est True (z référence la même liste que x). x is y est False (x et y sont des objets liste différents, même si leur contenu est identique).
is not	Renvoie True si les deux variables pointent vers des objets différents en mémoire.	x is not y est True. x is not z est False.

Note : Utilisez is pour la comparaison d’identité (même objet), et == pour la comparaison d’égalité (même valeur).

Précedence des opérateurs Python

Lorsqu’une expression contient plusieurs opérateurs, Python les évalue dans un ordre spécifique basé sur la précédence. Les opérateurs de plus haute précédence sont évalués en premier. Les parenthèses () peuvent être utilisées pour outrepasser la précédence par défaut.

Le tableau suivant liste les opérateurs de la plus haute précédence (en haut) à la plus basse (en bas) :

Opérateur	Description
()	Parenthèses (groupement)
f(args...), x[index], x[index:slice], x.attribute	Appels de fonction, indexation, découpage, référence d’attribut
await x	Expression await
**	Exponentiation (associative à droite)
+x, -x, ~x	Positif, négatif, NON binaire (unaire)
*, /, //, %	Multiplication, division, division entière, modulo
+, -	Addition et soustraction
<<, >>	Décalages binaires gauche et droite
&	ET binaire
^	OU exclusif binaire
|	OU binaire
in, not in, is, is not, <, <=, >, >=, !=, ==	Comparaisons, y compris les tests d’appartenance et d’identité
not x	NON logique
and	ET logique
or	OU logique
if else	Expression conditionnelle
lambda	Expression lambda
:=	Expression d’affectation (opérateur morse)

Comprendre la précédence des opérateurs aide à écrire du code prévisible et correct.