Comprendre les Opérateurs en Python

Introduction

Dans ce laboratoire, vous acquerrez une compréhension complète des différents opérateurs en Python, un concept fondamental pour écrire du code efficace. Nous explorerons et pratiquerons l'utilisation des opérateurs arithmétiques, de comparaison, d'affectation, logiques, binaires (bitwise), d'appartenance (membership) et d'identité (identity).

Grâce à des exercices pratiques utilisant l'éditeur VS Code intégré et le terminal, vous apprendrez à effectuer des calculs, à établir des comparaisons, à affecter des valeurs, à combiner des conditions, à manipuler des bits, à vérifier l'appartenance et à comparer les identités d'objets. À la fin de ce laboratoire, vous maîtriserez l'utilisation de ces opérateurs pour construire des programmes Python plus complexes et fonctionnels.

Explorer les Opérateurs Arithmétiques et de Comparaison

Dans cette étape, nous allons explorer les opérateurs arithmétiques et de comparaison fondamentaux en Python. Ces opérateurs sont essentiels pour effectuer des calculs et prendre des décisions dans vos programmes. L'environnement de laboratoire a déjà créé un fichier nommé operators.py pour vous dans le répertoire ~/project.

Tout d'abord, localisez le fichier operators.py dans l'explorateur de fichiers sur le côté gauche de l'éditeur VS Code et ouvrez-le. Nous écrirons tout notre code dans ce fichier unique.

Commençons par les opérateurs arithmétiques. Ajoutez le code Python suivant au fichier operators.py :

## Arithmetic Operators
a = 21
b = 5
print(f'{a} + {b} = {a + b}')
print(f'{a} - {b} = {a - b}')
print(f'{a} * {b} = {a * b}')
print(f'{a} / {b} = {a / b}') ## Division standard
print(f'{a} // {b} = {a // b}')  ## Division entière (Floor division), arrondit à l'entier inférieur
print(f'{a} % {b} = {a % b}')  ## Modulo, retourne le reste
print(f'{a} ** {b} = {a ** b}')  ## Exponentiation, a à la puissance b

Après avoir ajouté le code, enregistrez le fichier en appuyant sur Ctrl + S.

Pour exécuter le script, ouvrez le terminal intégré dans VS Code en sélectionnant Terminal > New Terminal dans le menu supérieur. Ensuite, exécutez la commande suivante :

python ~/project/operators.py

Vous devriez voir la sortie suivante dans le terminal :

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

Ensuite, explorons les opérateurs de comparaison. Ces opérateurs comparent deux valeurs et retournent une valeur booléenne (True ou False).

Ajoutez le code suivant à la fin de votre fichier operators.py :

## Comparison Operators
print("\n--- Comparison Operators ---")
a = 6
b = 5
print(f'{a} == {b} is {a == b}')  ## Égal à
print(f'{a} != {b} is {a != b}')  ## Différent de
print(f'{a} > {b} is {a > b}')    ## Supérieur à
print(f'{a} < {b} is {a < b}')    ## Inférieur à
print(f'{a} >= {b} is {a >= b}')  ## Supérieur ou égal à
print(f'{a} <= {b} is {a <= b}')  ## Inférieur ou égal à

Enregistrez à nouveau le fichier et exécutez-le depuis le terminal :

python ~/project/operators.py

La sortie inclura désormais les résultats des opérations de comparaison :

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

--- Comparison Operators ---
6 == 5 is False
6 != 5 is True
6 > 5 is True
6 < 5 is False
6 >= 5 is True
6 <= 5 is False

Vous avez maintenant utilisé avec succès les opérateurs arithmétiques et de comparaison dans un script Python.

Pratiquer les Opérateurs d'Affectation et Logiques

Dans cette étape, nous allons nous exercer à utiliser les opérateurs d'affectation (assignment operators) et les opérateurs logiques. Les opérateurs d'affectation sont utilisés pour assigner ou mettre à jour la valeur d'une variable, tandis que les opérateurs logiques sont utilisés pour combiner des énoncés conditionnels.

Continuez à travailler avec le fichier operators.py dans l'éditeur VS Code.

Tout d'abord, ajoutons des exemples d'opérateurs d'affectation. Ceux-ci offrent une manière abrégée d'effectuer une opération et de réaffecter le résultat à la même variable.

Ajoutez le code suivant à la fin de votre fichier operators.py :

## Assignment Operators
print("\n--- Assignment Operators ---")
a = 10
b = 3
print(f'Initial a: {a}')

c = a
c += b  ## Équivalent à c = c + b
print(f'a += b: {c}')

c = a
c -= b  ## Équivalent à c = c - b
print(f'a -= b: {c}')

c = a
c *= b  ## Équivalent à c = c * b
print(f'a *= b: {c}')

c = a
c /= b  ## Équivalent à c = c / b
print(f'a /= b: {c}')

## Walrus operator (Python 3.8+)
## Il assigne une valeur à une variable dans le cadre d'une expression plus large.
print("\n--- Walrus Operator ---")
text = 'hello python'
if (n := len(text)) > 10:
    print(f'The string is long enough ({n} characters)')

Enregistrez le fichier et exécutez-le depuis le terminal :

python ~/project/operators.py

Vous devriez voir la sortie pour les opérateurs d'affectation :

... (output from previous step) ...

--- Assignment Operators ---
Initial a: 10
a += b: 13
a -= b: 7
a *= b: 30
a /= b: 3.3333333333333335

--- Walrus Operator ---
The string is long enough (12 characters)

Maintenant, ajoutons des exemples d'opérateurs logiques (and, or, not). Ces opérateurs fonctionnent avec des valeurs booléennes, mais ils peuvent également fonctionner avec d'autres types. En Python, les valeurs comme 0, None, et les collections vides ('', [], {}) sont considérées comme False (falsy). Toutes les autres valeurs sont considérées comme True (truthy).

Ajoutez le code suivant à la fin de votre fichier operators.py :

## Logical Operators
print("\n--- Logical Operators ---")
x = True
y = False

print(f'{x} and {y} is {x and y}')
print(f'{x} or {y} is {x or y}')
print(f'not {x} is {not x}')

## Evaluation with non-boolean values
a = 10  ## True
b = 0   ## False
print(f'{a} and {b} returns {a and b}') ## Retourne la première valeur Falsy ou la dernière valeur Truthy
print(f'{a} or {b} returns {a or b}')   ## Retourne la première valeur Truthy ou la dernière valeur Falsy

Enregistrez le fichier et exécutez-le à nouveau :

python ~/project/operators.py

La sortie inclura maintenant les résultats des opérations logiques :

... (output from previous examples) ...

--- Logical Operators ---
True and False is False
True or False is True
not True is False
10 and 0 returns 0
10 or 0 returns 10

Vous vous êtes maintenant exercé à utiliser les opérateurs d'affectation et logiques en Python.

Apprendre les Opérateurs Bit à Bit (Bitwise)

Dans cette étape, nous allons découvrir les opérateurs bit à bit. Ces opérateurs effectuent des opérations directement sur la représentation binaire (base 2) des entiers. Ceci est utile pour la manipulation de données de bas niveau.

Continuez à modifier le fichier operators.py.

Tout d'abord, voyons la représentation binaire de quelques nombres en utilisant la fonction bin(). Le préfixe 0b indique que les chiffres suivants sont binaires.

Ajoutez ce code à la fin de operators.py :

## Bitwise Operators
print("\n--- Bitwise Operators ---")
a = 5  ## Binary: 0b101
b = 9  ## Binary: 0b1001
print(f'Binary of {a} is {bin(a)}')
print(f'Binary of {b} is {bin(b)}')

## For clarity, let's align them with 4 bits:
## a = 0101
## b = 1001

## Bitwise AND (&): Définit chaque bit à 1 si les deux bits sont 1.
## 0101 & 1001 = 0001 (Décimal 1)
print(f'{a} & {b} = {a & b}')

## Bitwise OR (|): Définit chaque bit à 1 si l'un des deux bits est 1.
## 0101 | 1001 = 1101 (Décimal 13)
print(f'{a} | {b} = {a | b}')

## Bitwise XOR (^): Définit chaque bit à 1 si un seul des deux bits est 1.
## 0101 ^ 1001 = 1100 (Décimal 12)
print(f'{a} ^ {b} = {a ^ b}')

## Bitwise NOT (~): Inverse tous les bits.
## ~a est équivalent à -(a+1)
print(f'~{a} = {~a}')

## Décalage à gauche (Left Shift - <<): Décale les bits vers la gauche, remplissant par des zéros.
## Équivalent à multiplier par 2**n.
## 5 << 2 signifie que 0101 devient 10100 (Décimal 20)
print(f'{a} << 2 = {a << 2}')

## Décalage à droite (Right Shift - >>): Décale les bits vers la droite, en écartant les bits de droite.
## Équivalent à une division entière par 2**n.
## 9 >> 2 signifie que 1001 devient 10 (Décimal 2)
print(f'{b} >> 2 = {b >> 2}')

Enregistrez le fichier et exécutez le script depuis le terminal :

python ~/project/operators.py

Vous verrez la sortie démontrant chaque opération bit à bit :

... (output from previous steps) ...

--- Bitwise Operators ---
Binary of 5 is 0b101
Binary of 9 is 0b1001
5 & 9 = 1
5 | 9 = 13
5 ^ 9 = 12
~5 = -6
5 << 2 = 20
9 >> 2 = 2

Vous avez maintenant appris à utiliser les opérateurs bit à bit pour manipuler les entiers au niveau du bit.

Utiliser les Opérateurs d'Appartenance et d'Identité

Dans cette dernière étape, nous allons aborder les opérateurs d'appartenance (in, not in) et les opérateurs d'identité (is, is not). Les opérateurs d'appartenance vérifient si une valeur est présente dans une séquence, tandis que les opérateurs d'identité vérifient si deux variables font référence au tout même objet en mémoire.

Continuez à travailler avec le fichier operators.py.

Tout d'abord, ajoutons des exemples d'opérateurs d'appartenance. Ils sont couramment utilisés avec des séquences telles que les listes, les tuples et les chaînes de caractères (strings).

Ajoutez le code suivant à la fin de votre fichier operators.py :

## Membership Operators
print("\n--- Membership Operators ---")
my_list = [1, 3, 5, 7]
print(f'3 in {my_list} is {3 in my_list}')
print(f'4 not in {my_list} is {4 not in my_list}')

greeting = "hello world"
print(f'"world" in "{greeting}" is {"world" in greeting}')

Enregistrez le fichier et exécutez-le :

python ~/project/operators.py

La sortie pour les opérateurs d'appartenance sera :

... (output from previous steps) ...

--- Membership Operators ---
3 in [1, 3, 5, 7] is True
4 not in [1, 3, 5, 7] is True
"world" in "hello world" is True

Maintenant, explorons les opérateurs d'identité. Il est important de comprendre la différence entre is (identité) et == (égalité). == vérifie si les valeurs de deux objets sont identiques, tandis que is vérifie s'ils sont le même objet (c'est-à-dire s'ils ont la même adresse mémoire).

Ajoutez le code suivant à votre fichier operators.py :

## Identity Operators
print("\n--- Identity Operators ---")

## For small integers, Python often reuses the same object.
x = 256
y = 256
print(f'x is y (for 256): {x is y}') ## Ceci est souvent True

## For larger integers, Python may create separate objects.
a = 257
b = 257
print(f'a is b (for 257): {a is b}') ## Ceci est souvent False

## For mutable objects like lists, they are different objects even if their content is the same.
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'list1 == list2: {list1 == list2}') ## Vérifie l'égalité du contenu (True)
print(f'list1 is list2: {list1 is list2}') ## Vérifie s'il s'agit du même objet (False)
print(f'list1 is not list2: {list1 is not list2}') ## Vérifie s'il s'agit d'objets différents (True)

Enregistrez le fichier et exécutez-le une dernière fois :

python ~/project/operators.py

La sortie démontre la différence entre l'égalité et l'identité :

... (output from previous examples) ...

--- Identity Operators ---
x is y (for 256): True
a is b (for 257): True
list1 == list2: True
list1 is list2: False
list1 is not list2: True

Vous avez réussi à utiliser les opérateurs d'appartenance et d'identité, complétant ainsi votre exploration des principaux types d'opérateurs de Python.

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique avec les différents types d'opérateurs en Python. Vous avez commencé par explorer les opérateurs arithmétiques et de comparaison fondamentaux pour effectuer des calculs et évaluer des conditions. Vous vous êtes ensuite exercé à utiliser les opérateurs d'affectation (assignment operators) pour des mises à jour efficaces des variables et les opérateurs logiques pour combiner la logique conditionnelle.

De plus, vous avez exploré les opérateurs bit à bit (bitwise operators) pour comprendre la manipulation de données de bas niveau et avez terminé avec les opérateurs d'appartenance (membership operators) et d'identité (identity operators) pour vérifier la présence d'éléments et l'identité des objets. En écrivant et en exécutant du code pour chaque type d'opérateur dans l'éditeur VS Code, vous avez bâti une base solide pour utiliser ces outils essentiels dans votre future programmation Python.