Comprendre les variables Python : un guide complet

Une variable est une étiquette nommée qui pointe vers une valeur stockée en mémoire. Les variables sont le principal moyen de conserver, de transmettre et de transformer des données dans tout programme Python. Contrairement à certains langages, Python ne vous oblige pas à déclarer un type — vous assignez simplement une valeur et Python détermine le type pour vous.

Cette page couvre :

• Comment créer et assigner des variables
• Le typage dynamique — ce que cela signifie en pratique
• L'affectation multiple et le déballage de tuple
• Les opérateurs d'affectation augmentée
• Vérifier le type d'une variable avec type()
• La valeur spéciale None
• Supprimer des variables avec del
• Les bases de la portée des variables

Chapitres associés : Noms de variables · Variables de sortie · Assigner plusieurs valeurs · Types de données Python · Variables globales · Portée Python

Créer une variable

Pour créer une variable, écrivez un nom, puis =, puis la valeur. Python crée la variable et la lie immédiatement à cette valeur.

Assigner une string et l'afficher

John Doe

Ici name est le nom de la variable et "John Doe" est la valeur. Le signe = est l'opérateur d'affectation — ce n'est pas un test d'égalité (c'est ==).

Les noms de variables obéissent à quelques règles :

• Doivent commencer par une lettre ou un trait de soulignement (_), jamais par un chiffre.
• Peuvent contenir des lettres, des chiffres et des traits de soulignement.
• Sont sensibles à la casse — score, Score et SCORE sont trois variables différentes.
• Ne peuvent pas être un mot-clé Python tel que if, for, while ou class.

Le style Python (PEP 8) recommande le snake_case pour les noms de variables : des mots en minuscules séparés par des traits de soulignement, comme first_name ou total_price. Pour les bonnes pratiques de nommage, voir Noms de variables.

Typage dynamique

Python est dynamiquement typé : une variable n'a pas de type fixe. Le type est déterminé par la valeur qui lui est actuellement assignée et peut changer lorsque vous la réassignez.

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = 3.14
print(type(x))   # <class 'float'>

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

Cette flexibilité est pratique mais constitue aussi une source courante de bogues : si vous écrasez accidentellement une variable avec une valeur du mauvais type, Python ne vous avertira pas — seule une TypeError (ou un résultat erroné) à l'exécution vous le signalera. Les annotations de type (par ex. x: int = 10) permettent de documenter l'intention et de détecter de telles erreurs en amont avec un vérificateur de type. Voir Python Type Hints pour plus de détails.

Vérifier le type d'une variable

Utilisez la fonction intégrée type() pour inspecter le type que contient actuellement une variable :

name = "Alice"
age = 30
price = 9.99
active = True

print(type(name))    # <class 'str'>
print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>
print(type(active))  # <class 'bool'>

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

type() est particulièrement utile lors du débogage — lorsqu'une variable contient un type inattendu, print(type(x)) est le moyen le plus rapide de confirmer ce qu'elle contient réellement.

Variables pour chaque type de données

Python dispose d'un riche ensemble de types intégrés. Voici un bloc unique qui crée une variable de chaque type courant afin que vous puissiez voir le schéma de nommage en un coup d'œil :

Assigner des variables de différents types

integer_val  = 10                          # int
float_val    = 10.5                        # float
complex_val  = 10 + 5j                     # complex
string_val   = "Hello, World!"             # str
bool_val     = True                        # bool
list_val     = [1, 2, 3, 4, 5]            # list  (mutable, ordered)
tuple_val    = (1, 2, 3, 4, 5)            # tuple (immutable, ordered)
dict_val     = {"key1": "value1"}          # dict  (key-value pairs)
set_val      = {1, 2, 3, 4, 5}            # set   (unique, unordered)
none_val     = None                        # NoneType

Pour une analyse approfondie du choix de chaque type, voir Types de données Python.

Affectation multiple

Assigner la même valeur à plusieurs variables

Vous pouvez chaîner = pour assigner la même valeur à plusieurs variables en une seule ligne :

a = b = c = 0
print(a, b, c)

0 0 0

C'est utile pour initialiser des compteurs ou des indicateurs, mais faites attention avec les objets mutables — a = b = c = [] fait pointer les trois noms vers la même liste, donc modifier l'un modifie les trois.

Déballage de tuple

Assignez des valeurs différentes à plusieurs variables sur une seule ligne en les séparant par des virgules :

x, y, z = 1, 2, 3
print(x, y, z)

1 2 3

Python associe les valeurs du membre droit aux noms du membre gauche dans l'ordre. Le nombre de noms doit être égal au nombre de valeurs, sinon vous obtenez une ValueError. Pour le déballage avec étoile (*) et imbriqué, voir Assigner plusieurs valeurs.

Opérateurs d'affectation augmentée

Une affectation augmentée combine une opération et une affectation en une seule étape. Au lieu d'écrire count = count + 1, vous écrivez count += 1 :

count = 0
count += 1    # same as count = count + 1
print(count)  # 1

total = 100
total -= 25   # same as total = total - 25
print(total)  # 75

price = 10.0
price *= 1.2  # same as price = price * 1.2
print(price)  # 12.0

1
75
12.0

L'ensemble complet des opérateurs d'affectation augmentée est +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= et <<=. Ils fonctionnent avec tout type qui prend en charge l'opérateur sous-jacent — par exemple, += sur une string effectue une concaténation :

message = "Hello"
message += ", World!"
print(message)

Hello, World!

Arithmétique avec les variables

Les variables contenant des nombres peuvent être utilisées dans des expressions arithmétiques. Python évalue l'expression et renvoie une nouvelle valeur :

Calculs avec des variables

a = 10
b = 20

print(a + b)   # addition       → 30
print(b - a)   # subtraction    → 10
print(a * b)   # multiplication → 200
print(b / a)   # division       → 2.0  (always float in Python 3)
print(b // a)  # floor division → 2
print(b % a)   # modulo         → 0

30
10
200
2.0
2
0

Notez que / renvoie toujours un float en Python 3, même quand le résultat est un nombre entier. Utilisez // lorsque vous avez besoin d'un quotient entier.

Pour la liste complète des opérateurs (bit à bit, comparaison, logique, appartenance, identité), voir Opérateurs Python.

La valeur spéciale None

None est la façon dont Python représente « aucune valeur » ou « rien ». C'est la seule valeur du type NoneType :

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>
print(result is None) # True

None
<class 'NoneType'>
True

Testez toujours None avec is None (vérification d'identité), et non == None (vérification d'égalité). Les fonctions qui ne renvoient pas explicitement une valeur renvoient None par défaut.

Supprimer une variable

Utilisez l'instruction del pour supprimer un nom de variable de la portée courante. Après la suppression, référencer ce nom lève une NameError :

temp = "temporary value"
print(temp)  # temporary value

del temp
# print(temp)  # NameError: name 'temp' is not defined

del est le plus souvent utilisé pour libérer explicitement de la mémoire (par ex. après le traitement d'un grand ensemble de données) ou pour nettoyer l'état local. Il supprime la liaison du nom, pas nécessairement l'objet sous-jacent — le ramasse-miettes de Python récupère la mémoire de l'objet lorsqu'aucun nom ne pointe vers lui.

Bases de la portée des variables

L'accessibilité d'une variable dépend de l'endroit où elle est définie. Les deux portées les plus courantes sont :

• Portée locale — une variable créée à l'intérieur d'une fonction n'existe que le temps de l'appel de cette fonction.
• Portée globale — une variable créée au niveau supérieur d'un module est accessible de partout dans ce module.

message = "I am global"   # global variable

def greet():
    greeting = "Hello"    # local variable — not accessible outside
    print(greeting)
    print(message)        # can read global variable

greet()
# print(greeting)  # NameError — greeting does not exist here

Hello
I am global

Modifier une variable globale depuis l'intérieur d'une fonction nécessite le mot-clé global. Voir Variables globales et Portée Python pour la règle LEGB complète.

Pratique