# Leçon 1 : Les Variables, Types et Opérateurs ## Objectifs de la leçon À la fin de cette leçon, tu seras capable de : - comprendre ce qu'est réellement une variable en Python (et pourquoi ce n'est pas une "boîte") ; - expliquer le principe **"tout est objet"** ; - distinguer l'**identité** et l'**égalité** d'un objet ; - distinguer les objets **mutables** et **immuables** ; - connaître les types de base et les opérateurs du langage. --- ## 1. Le modèle mental : "tout est objet" En Python, **tout ce que tu manipules est un objet** : un nombre, une chaîne de caractères, une liste, une fonction, une classe, même un module. Chaque objet possède trois caractéristiques : 1. **Une identité** — un identifiant unique en mémoire, propre à cet objet, qu'on peut consulter avec `id()`. Elle ne change jamais pendant la durée de vie de l'objet. 2. **Un type** — ce que l'objet *est* (`int`, `str`, `list`...), consultable avec `type()`. Il détermine les opérations possibles sur l'objet. 3. **Une valeur** — les données que l'objet contient. ```python x = 10 print(id(x)) # identité (adresse mémoire) de l'objet 10 print(type(x)) # ``` Ce principe change la façon de comprendre les variables : une variable n'est **pas** une boîte qui contient une valeur, comme dans d'autres langages. C'est une **étiquette** posée sur un objet. --- ## 2. Les variables sont des références Quand tu écris `x = 10`, Python fait deux choses, dans cet ordre : 1. il crée l'objet `10` en mémoire ; 2. il fait pointer le nom `x` vers cet objet. `x` ne "contient" pas `10` : `x` **référence** (pointe vers) l'objet `10`. ```python x = 10 y = x # y pointe vers le MÊME objet que x print(id(x) == id(y)) # True ``` ### 2.1 Conséquence : plusieurs noms peuvent pointer vers le même objet ```python a = [1, 2, 3] b = a # b et a référencent la même liste b.append(4) print(a) # [1, 2, 3, 4] <- a a "vu" le changement ! ``` Ici, `a` et `b` ne sont pas deux listes séparées : ce sont deux étiquettes sur **le même** objet liste. Modifier l'objet via `b` est visible via `a`. ### 2.2 Identité (`is`) vs égalité (`==`) - `==` compare les **valeurs** de deux objets (ont-ils le même contenu ?). - `is` compare l'**identité** de deux objets (sont-ils *littéralement* le même objet en mémoire ?). ```python a = [1, 2, 3] b = [1, 2, 3] c = a print(a == b) # True -> même valeur print(a is b) # False -> deux objets différents en mémoire print(a is c) # True -> c'est littéralement le même objet ``` > 💡 Règle pratique : utilise toujours `==` pour comparer des valeurs. Réserve `is` à des cas précis, comme `x is None`. ### 2.3 Réaffecter une variable ne modifie pas l'objet ```python x = 10 y = x x = 20 # x pointe maintenant vers un NOUVEL objet 20 print(y) # 10 -> y n'a pas changé, il pointe toujours vers l'ancien objet ``` Ici, `x = 20` ne modifie pas l'objet `10` : il fait pointer `x` vers un objet différent. `y` continue de référencer l'ancien objet. --- ## 3. Mutabilité vs immuabilité C'est la notion la plus importante à retenir avec celle de référence : certains objets peuvent être modifiés "en place" (mutables), d'autres non (immuables). | Immuables (ne changent jamais après création) | Mutables (modifiables en place) | |---|---| | `int`, `float`, `bool` | `list` | | `str` | `dict` | | `tuple` | `set` | | `frozenset` | | ```python # str est immuable : chaque "modification" crée un NOUVEL objet s = "bonjour" print(id(s)) s = s.upper() print(id(s)) # id différent -> nouvel objet créé # list est mutable : on modifie le MÊME objet liste = [1, 2, 3] print(id(liste)) liste.append(4) print(id(liste)) # même id -> objet modifié en place ``` Cette distinction explique le comportement vu en 2.1 : modifier une liste partagée affecte toutes les variables qui la référencent, alors que ce n'est jamais le cas pour un `int` ou une `str`. --- ## 4. Les règles de nommage des variables - Le nom commence par une lettre ou un `_` (jamais par un chiffre). - Il peut contenir lettres, chiffres et `_`. - Python est **sensible à la casse** : `age` et `Age` sont deux variables différentes. - Convention : on utilise le style `snake_case`. ```python # Valides nom_complet = "Fatou Diop" _compteur = 0 age2 = 30 # Invalides 2age = 30 # commence par un chiffre nom-complet = "x" # le tiret n'est pas autorisé ``` ### Affectation multiple ```python x, y, z = 1, 2, 3 a = b = c = 0 # les trois noms pointent vers le même objet 0 ``` --- ## 5. Les types de données de base | Type | Description | Mutable ? | Exemple | |------------|--------------------------------|-----------|-----------------| | `int` | Nombre entier | Non | `10`, `-5` | | `float` | Nombre décimal | Non | `3.14` | | `str` | Chaîne de caractères | Non | `"Bonjour"` | | `bool` | Booléen | Non | `True`, `False` | | `NoneType` | Absence de valeur | Non | `None` | ```python age = 25 print(type(age)) # taille = 1.75 print(type(taille)) # nom = "Ali" print(type(nom)) # est_actif = False print(type(est_actif)) # ``` ### Conversion de types (casting) ```python x = "10" y = int(x) # 10 z = float(x) # 10.0 age = 25 texte = str(age) # "25" ``` ⚠️ Convertir un texte non numérique en `int` provoque une erreur : `int("bonjour")` lève un `ValueError`. --- ## 6. Les opérateurs ### 6.1 Opérateurs arithmétiques | Opérateur | Signification | Exemple | Résultat | |-----------|---------------------|----------|----------| | `+` | Addition | `5 + 3` | `8` | | `-` | Soustraction | `5 - 3` | `2` | | `*` | Multiplication | `5 * 3` | `15` | | `/` | Division réelle | `5 / 2` | `2.5` | | `//` | Division entière | `5 // 2` | `2` | | `%` | Modulo (reste) | `5 % 2` | `1` | | `**` | Puissance | `5 ** 2` | `25` | ### 6.2 Opérateurs de comparaison Renvoient toujours un `bool`. | Opérateur | Signification | Exemple | Résultat | |-----------|-------------------------|----------|----------| | `==` | Égal (en valeur) | `5 == 5` | `True` | | `!=` | Différent | `5 != 3` | `True` | | `>` | Supérieur à | `5 > 3` | `True` | | `<` | Inférieur à | `5 < 3` | `False` | | `>=` | Supérieur ou égal | `5 >= 5` | `True` | | `<=` | Inférieur ou égal | `5 <= 3` | `False` | ### 6.3 Opérateurs logiques | Opérateur | Signification | Exemple | Résultat | |-----------|-------------------------------|----------------------|----------| | `and` | Vrai si les deux sont vrais | `True and False` | `False` | | `or` | Vrai si au moins un est vrai | `True or False` | `True` | | `not` | Inverse la valeur | `not True` | `False` | ### 6.4 Opérateurs d'affectation ```python x = 5 x += 3 # x = x + 3 -> 8 x -= 2 # x = x - 2 -> 6 x *= 2 # x = x * 2 -> 12 x /= 3 # x = x / 3 -> 4.0 ``` ### 6.5 Opérateurs d'identité et d'appartenance | Opérateur | Signification | Exemple | |-----------|----------------------------------------|----------------------| | `is` | Même objet en mémoire ? | `x is None` | | `is not` | Objets différents ? | `x is not None` | | `in` | Élément présent dans une collection ? | `3 in [1, 2, 3]` | | `not in` | Élément absent ? | `4 not in [1, 2, 3]` | --- ## 7. Exemple récapitulatif ```python # Déclaration de variables (chacune référence un objet) nom = "Moussa" age = 20 taille = 1.80 est_majeur = age >= 18 print("Nom :", nom) print("Âge :", age) print("Taille :", taille) print("Est majeur :", est_majeur) # Deux variables qui référencent le même objet mutable amis = ["Awa", "Ibou"] copains = amis copains.append("Seydou") print(amis) # ['Awa', 'Ibou', 'Seydou'] -> visible aussi via amis ``` **Sortie attendue :** ``` Nom : Moussa Âge : 20 Taille : 1.8 Est majeur : True ['Awa', 'Ibou', 'Seydou'] ``` --- ## 8. Exercices pratiques 1. Crée une variable `prenom` et une variable `age`, puis affiche : `"Je m'appelle X et j'ai Y ans."` 2. Déclare deux nombres et calcule leur somme, différence, produit et quotient. 3. Vérifie avec `type()` le type de : `10`, `"10"`, `10.0`, `True`. 4. Crée une liste `a = [1, 2, 3]`, affecte `b = a`, modifie `b`, puis affiche `a`. Explique le résultat avec le vocabulaire "référence" et "objet mutable". 5. Refais l'exercice 4 avec deux entiers au lieu d'une liste (`x = 5`, `y = x`, modifie `y`). Explique pourquoi le résultat est différent. 6. Utilise `is` et `==` pour comparer deux listes ayant le même contenu mais créées séparément. Explique la différence de résultat. --- ## 9. Résumé - **Tout est objet** en Python : chaque objet a une identité (`id()`), un type (`type()`) et une valeur. - Une **variable n'est pas une boîte**, c'est un nom qui **référence** un objet. - `==` compare les valeurs, `is` compare l'identité (le même objet en mémoire). - Les objets sont soit **immuables** (`int`, `float`, `str`, `bool`, `tuple`), soit **mutables** (`list`, `dict`, `set`) — cette distinction explique pourquoi deux variables qui référencent le même objet mutable "voient" les mêmes changements. - Les opérateurs permettent de faire des calculs (`+ - * / // % **`), des comparaisons (`== != > < >= <=`), des combinaisons logiques (`and`, `or`, `not`) et de tester l'identité/l'appartenance (`is`, `in`). ➡️ **Prochaine leçon : Les collections (tuple, list, dict, set)** — où cette notion de mutabilité prendra tout son sens.

Débloquez l'accès complet à la Suite d'Ingénierie KsiLoG Academy.