Types de données et variables en Python

Types de données

Définition — Type de données Un type de donnéesest une catégorisation qui détermine :

l'ensemble des valeurs possibles (ex. : int → nombres entiers)
les opérations applicables sur ces valeurs (ex. : addition, concaténation)
la représentation en mémoire de ces valeurs

Notion de littéral Les valeurs écrites directement dans le code source sont appelées littéraux. Chaque littéral est automatiquement associé à un type : 10 → int, 88.22 → float, "pypi" → str.

Le tableau suivant présente les types de données de base en Python :

Catégorie	Type Python	Exemples de littéraux	Opérations typiques
Entiers	`int`	`12`, `-999`, `0`, `900000`	`+`, `-`, `*`, `//`, `%`
Réels	`float`	`4.5`, `0.0003`, `-90.5`, `3.0`	`+`, `-`, ``, `/`, `*`
Chaînes	`str`	`'hello'`, `"100"`, `"$$$"`, `""`	`+`, `*`, `len()`, slicing
Booléens	`bool`	`True`, `False`	`and`, `or`, `not`

La fonction `type()`

Python fournit la fonction intégrée type() pour déterminer le type d'une valeur ou d'une variable à l'exécution.

Syntaxe Python

type(expression)   # retourne le type de l'expression

Exemple n°1 — Utilisation de type()

print(type(54))        # int
print(type("Bonjour")) # str
print(type(98.188))    # float
print(type("3.14"))    # str  ← guillemets → chaîne, pas un float !
print(type("99"))      # str  ← guillemets → chaîne, pas un int !
print(type(True))      # bool

Sortie

<class 'int'>
<class 'str'>
<class 'float'>
<class 'str'>
<class 'str'>
<class 'bool'>

Attention — Guillemets = chaîne "3.14" et "99" sont des chaînes de caractères, pas des nombres. Les guillemets (simples ou doubles) font toujours du littéral un str, quelle que soit la valeur à l'intérieur.

Variables

Définition — Variable Une variable est un nom symbolique associé à un emplacement mémoire contenant une valeur. En Python, une variable n'est pas un "conteneur" au sens strict : c'est une étiquette (référence) pointant vers un objet en mémoire.

Déclaration et affectation

Syntaxe Python

nom_variable = expression

L'opérateur = est l'opérateur d'affectation. Il évalue l'expression à droite puis fait pointer la variable vers l'objet résultant.

Exemple n°2 — Affectation simple

a = 5
nom = "Mostafa"
pi  = 3.14159

print(a, nom, pi)

Sortie

5 Mostafa 3.14159

Remarque — Référence, pas copie En Python, a = 5 ne "stocke pas 5 dans a". Python crée un objet int de valeur 5 en mémoire, puis fait pointer l'étiquette a vers cet objet. C'est pourquoi on parle de référence, pas de valeur.

Typage dynamique

Contrairement à C, C++ ou Java, Python ne demande pas de déclarer le type d'une variable. Le type est déterminé automatiquement à l'exécution selon la valeur affectée : c'est le typage dynamique.

	C / Java	Python
Déclaration du type	Obligatoire : `int a = 2;`	Interdite : `a = 2`
Changement de type	Impossible (typage statique)	Possible (typage dynamique)
Vérification du type	À la compilation	À l'exécution

Exemple n°3 — Typage dynamique

a = 2
print(type(a))   # int

a = "bonjour"
print(type(a))   # str — même variable, type différent !

a = 3.14
print(type(a))   # float

Sortie

<class 'int'>
<class 'str'>
<class 'float'>

Exemple n°4 — Erreur : déclaration de type interdite

int a = 2   # ❌ SyntaxError en Python !

Sortie

File "<stdin>", line 1
    int a = 2
        ^
SyntaxError: invalid syntax

Règles de nommage des variables

Règles — Noms de variables valides

Seuls les caractères a-z, A-Z, 0-9 et _ sont autorisés.
Le nom doit commencer par une lettre ou un underscore _ (jamais par un chiffre).
Les mots-clés réservés (for, if, class…) sont interdits comme noms.
Python est sensible à la casse : age, Age et AGE sont trois variables différentes.
La longueur du nom est illimitée (mais rester concis et descriptif).

Nom	Valide ?	Raison
`ma_variable`	✅	Lettres et underscore
`_valeur`	✅	Commence par `_`
`var2`	✅	Chiffre en position non initiale
`2var`	❌	Commence par un chiffre
`mon-nom`	❌	Tiret `-` interdit
`for`	❌	Mot-clé réservé
`ma variable`	❌	Espace interdit

Astuce — Conventions de nommage (PEP 8)

Variables et fonctions : snake_case → nb_etudiants
Constantes : MAJUSCULES → PI = 3.14159
Classes : PascalCase → class EtudiantMaster
Privé : préfixe _ → _valeur_interne

Affectation simultanée

Python permet d'affecter des valeurs à plusieurs variables en une seule instruction. Les expressions à droite sont toutes évaluées avant toute affectation.

Syntaxe Python

var1, var2, ..., varN = exp1, exp2, ..., expN   # N variables ← N valeurs
var1 = var2 = var3 = expression                  # même valeur pour toutes

Exemple n°5 — Affectation multiple

a, nom, b = 2, "Mostafa", 3.5

print(f"a   = {a}   ({type(a).__name__})")
print(f"nom = {nom} ({type(nom).__name__})")
print(f"b   = {b}   ({type(b).__name__})")

Sortie

a   = 2      (int)
nom = Mostafa (str)
b   = 3.5    (float)

Exemple n°6 — Même valeur pour plusieurs variables

a = b = c = 4
print(a, b, c)   # 4 4 4

Sortie

4 4 4

Exemple n°7 — Échange de valeurs sans variable temporaire

x = 10
y = 25

x, y = y, x   # idiome Python : échange en une ligne

print(f"x = {x}")   # 25
print(f"y = {y}")   # 10

Sortie

x = 25
y = 10

Astuce — Échange en Python vs autres langagesEn C ou Java, échanger deux variables nécessite une variable temporaire :

# Méthode classique (C/Java style) — inutile en Python
tmp = x
x   = y
y   = tmp

# Méthode Python — concise et élégante
x, y = y, x

Précédent Instructions, Indentation et commentaires en Python

Suivant Entrée, sortie en python - input, print