Les opérateurs en python

En Python, les opérateurs sont des symboles qui permettent d'effectuer des opérations sur des variables et des valeurs. Voici un aperçu des différents types d'opérateurs :

1. Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques sur des nombres.

Addition (+) : Additionne deux nombres.
```
  a = 10
  b = 5
  c = a + b  # c = 15
```
Soustraction (-) : Soustrait un nombre d'un autre.
```
  c = a - b  # c = 5
```
Multiplication (*) : Multiplie deux nombres.
```
  c = a * b  # c = 50
```
Division (/) : Divise un nombre par un autre.
```
  c = a / b  # c = 2.0
```
Division entière (//) : Divise un nombre par un autre et retourne la partie entière du résultat.
```
  c = a // b  # c = 2
```
Modulo (%) : Retourne le reste de la division de deux nombres.
```
  c = a % b  # c = 0
```
Exponentiation (**) : Élève un nombre à la puissance d'un autre.
```
  c = a ** 2  # c = 100
```

2. Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour comparer deux valeurs.

Égalité (==) : Vérifie si deux valeurs sont égales.
```
  a == b  # False
```
Différence (!=) : Vérifie si deux valeurs sont différentes.
```
  a != b  # True
```
Supérieur (>) : Vérifie si la première valeur est supérieure à la seconde.
```
  a > b  # True
```
Inférieur (<) : Vérifie si la première valeur est inférieure à la seconde.
```
  a < b  # False
```
Supérieur ou égal (>=) : Vérifie si la première valeur est supérieure ou égale à la seconde.
```
  a >= b  # True
```
Inférieur ou égal (<=) : Vérifie si la première valeur est inférieure ou égale à la seconde.
```
  a <= b  # False
```

3. Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner des expressions conditionnelles.

Et logique (and) : Retourne True si les deux expressions sont vraies.
```
  a > 5 and b < 10  # True
```
Ou logique (or) : Retourne True si au moins une des expressions est vraie.
```
  a > 10 or b < 10  # True
```
Non logique (not) : Inverse la valeur logique de l'expression.
```
  not (a > 10)  # True
```

4. Opérateurs d'affectation

Les opérateurs d'affectation sont utilisés pour assigner des valeurs à des variables.

Affectation simple (=) : Assigne la valeur de droite à la variable de gauche.
```
  c = a + b  # c = 15
```
Affectation avec addition (+=) : Ajoute la valeur de droite à la variable de gauche.
```
  a += b  # a = 15
```
Affectation avec soustraction (-=) : Soustrait la valeur de droite de la variable de gauche.
```
  a -= b  # a = 10
```
Affectation avec multiplication (*=) : Multiplie la variable de gauche par la valeur de droite.
```
  a *= b  # a = 50
```
Affectation avec division (/=) : Divise la variable de gauche par la valeur de droite.
```
  a /= b  # a = 10.0
```
Affectation avec division entière (//=) : Effectue une division entière et affecte le résultat.
```
  a //= b  # a = 2
```
Affectation avec modulo (%=) : Applique l'opérateur modulo et affecte le résultat.
```
  a %= b  # a = 0
```
Affectation avec exponentiation (**=) : Applique l'opérateur d'exponentiation et affecte le résultat.
```
  a **= 2  # a = 100
```

5. Opérateurs bit à bit

Les opérateurs bit à bit sont utilisés pour manipuler les bits individuels des entiers.

ET bit à bit (&) : Effectue un ET logique sur chaque bit des opérandes.

  a = 5  # 0101 en binaire
  b = 3  # 0011 en binaire
  c = a & b  # 0001 en binaire, c = 1

OU bit à bit (|) : Effectue un OU logique sur chaque bit des opérandes.
```
  c = a | b  # 0111 en binaire, c = 7
```
OU exclusif bit à bit (^) : Effectue un XOR logique sur chaque bit des opérandes.
```
  c = a ^ b  # 0110 en binaire, c = 6
```
Décalage à gauche (<<) : Décale les bits d'un nombre vers la gauche.
```
  c = a << 1  # 1010 en binaire, c = 10
```
Décalage à droite (>>) : Décale les bits d'un nombre vers la droite.
```
  c = a >> 1  # 0010 en binaire, c = 2
```

6. Affectation parallèle

L'affectation parallèle permet d'assigner plusieurs variables en même temps.

x, y = 5, 10

Cela assigne 5 à x et 10 à y. On peut aussi échanger les valeurs de deux variables sans utiliser de variable temporaire :

x, y = y, x  # x prend la valeur de y et y prend la valeur de x

7. Opérateurs d'identité et d'appartenance

Opérateurs d'identité (is, is not) : Vérifient si deux variables pointent vers le même objet.

  a = [1, 2, 3]
  b = a
  c = [1, 2, 3]
  print(a is b)  # True, b pointe vers le même objet que a
  print(a is c)  # False, c est un autre objet avec la même valeur

Opérateurs d'appartenance (in, not in) : Vérifient si un élément fait partie d'une séquence (comme une liste ou une chaîne de caractères).
```
  d = 3
  print(d in [1, 2, 3])  # True
  print(d not in [1, 2, 3])  # False
```

Ces opérateurs sont essentiels pour écrire des scripts Python efficaces et lisibles, permettant de manipuler des données, de prendre des décisions et de contrôler le flux du programme.