Qu'est-ce qu'une variable en Python ?

Définition d'une variable en Python

Une variable en Python est un nom symbolique qui fait référence à une valeur stockée en mémoire. Contrairement à d'autres langages de programmation, Python ne nécessite pas de déclarer explicitement le type d'une variable : celui-ci est automatiquement déduit au moment de l'affectation. On parle alors de typage dynamique.

En d'autres termes, une variable est comme une étiquette que vous collez sur une boîte pour identifier ce qu'elle contient. Vous pouvez changer le contenu de la boîte à tout moment, et l'étiquette s'adaptera automatiquement. Si vous souhaitez approfondir ce concept fondamental ainsi que tous les autres piliers du langage, nous vous recommandons de suivre notre formation complète sur Python qui couvre ce sujet en détail.

Voici un exemple simple de création de variable :

nom = "Alice"
age = 30
taille = 1.72
est_actif = True

Dans cet exemple, nous avons créé quatre variables de types différents : une chaîne de caractères, un entier, un nombre à virgule flottante et un booléen. Python a déduit automatiquement le type de chacune d'entre elles.

Comment déclarer et affecter une variable

En Python, la déclaration et l'affectation d'une variable se font simultanément grâce à l'opérateur =. Il n'existe pas de mot-clé spécifique comme var ou let que l'on retrouve dans d'autres langages.

Affectation simple

La forme la plus courante consiste à attribuer une seule valeur à une seule variable :

# Affectation simple
prenom = "Marie"
points = 100
pi = 3.14159

Affectation multiple

Python vous permet d'affecter plusieurs variables en une seule ligne, ce qui peut rendre votre code plus concis :

# Affectation multiple sur une seule ligne
x, y, z = 10, 20, 30

# Affectation de la même valeur à plusieurs variables
a = b = c = 0

print(x, y, z)  # 10 20 30
print(a, b, c)  # 0 0 0

Réaffectation et changement de type

Grâce au typage dynamique, vous pouvez réaffecter une variable avec une valeur d'un type complètement différent :

ma_variable = 42
print(type(ma_variable))  # 

ma_variable = "Bonjour"
print(type(ma_variable))  # 

ma_variable = [1, 2, 3]
print(type(ma_variable))  # 

Les types de données fondamentaux

Chaque variable en Python possède un type qui détermine les opérations que vous pouvez effectuer dessus. Voici les types de données les plus courants :

Vous pouvez vérifier le type d'une variable à tout moment avec la fonction type() et vous pouvez exploiter des structures comme les list, les tuple, les dict ou les sets pour organiser vos données.

valeur = 3.14
print(type(valeur))  # 

print(isinstance(valeur, float))  # True
print(isinstance(valeur, int))    # False

Conventions de nommage

Python possède des règles strictes et des conventions fortement recommandées pour nommer vos variables. Les respecter est essentiel pour écrire un code lisible et professionnel.

Règles obligatoires

• Un nom de variable doit commencer par une lettre (a-z, A-Z) ou un underscore (_).
• Il peut contenir des lettres, des chiffres et des underscores.
• Il ne peut pas commencer par un chiffre.
• Il ne peut pas contenir d'espaces ni de caractères spéciaux (sauf _).
• Il est sensible à la casse : nom, Nom et NOM sont trois variables différentes.
• Il ne peut pas être un mot réservé de Python (comme if, for, while, class, def, lambda, global, nonlocal, yield, etc.).

Conventions recommandées (PEP 8)

La PEP 8, le guide de style officiel de Python, recommande les conventions suivantes :

# ✅ Bonnes pratiques de nommage
nom_utilisateur = "Alice"        # snake_case pour les variables
NOMBRE_MAX = 100                 # MAJUSCULES pour les constantes
_variable_privee = "interne"     # underscore pour indiquer un usage privé

# ❌ Mauvaises pratiques
nomUtilisateur = "Alice"         # camelCase (non recommandé en Python)
x = "Alice"                      # nom trop court et non descriptif
data = [1, 2, 3]                 # nom trop vague

Portée des variables (scope)

La portée (ou scope) d'une variable détermine où elle est accessible dans votre programme. Python suit la règle LEGB : Local, Enclosing, Global, Built-in.

Variables locales

Une variable définie à l'intérieur d'une fonction (def) n'est accessible que dans cette fonction :

def saluer():
    message = "Bonjour !"  # Variable locale
    print(message)

saluer()       # Bonjour !
# print(message)  # ❌ NameError: name 'message' is not defined

Variables globales

Une variable définie en dehors de toute fonction est une variable globale, accessible depuis n'importe où dans le module :

compteur = 0  # Variable globale

def incrementer():
    global compteur  # Déclarer l'intention de modifier la variable globale
    compteur += 1

incrémenter()
print(compteur)  # 1

Variables englobantes (enclosing)

Dans les fonctions imbriquées, vous pouvez accéder aux variables de la fonction englobante grâce au mot-clé nonlocal :

def exterieur():
    valeur = 10
    
    def interieur():
        nonlocal valeur
        valeur += 5
        print(f"Valeur intérieure : {valeur}")
    
    interieur()
    print(f"Valeur extérieure : {valeur}")

exterieur()
# Valeur intérieure : 15
# Valeur extérieure : 15

Variables et objets en mémoire

En Python, les variables ne contiennent pas directement les valeurs : elles sont des références vers des objets en mémoire. Comprendre ce mécanisme est fondamental pour éviter des comportements inattendus.

Identité et référence

Vous pouvez vérifier l'identité d'un objet avec la fonction id() :

a = [1, 2, 3]
b = a  # b pointe vers le même objet que a

print(id(a) == id(b))  # True : même objet en mémoire

b.append(4)
print(a)  # [1, 2, 3, 4] — a est aussi modifié !

Copie vs référence

Pour créer une copie indépendante d'un objet mutable, vous devez utiliser explicitement une méthode de copie :

import copy

# Copie superficielle
liste_originale = [1, 2, [3, 4]]
liste_copie = liste_originale.copy()  # ou list(liste_originale)

liste_copie[0] = 99
print(liste_originale)  # [1, 2, [3, 4]] — non modifiée

# Attention avec les objets imbriqués
liste_copie[2].append(5)
print(liste_originale)  # [1, 2, [3, 4, 5]] — modifiée !

# Copie profonde pour éviter cela
liste_profonde = copy.deepcopy(liste_originale)
liste_profonde[2].append(6)
print(liste_originale)  # [1, 2, [3, 4, 5]] — non modifiée

Objets mutables vs immuables

Cette distinction est cruciale pour comprendre le comportement des variables :

Lorsque vous modifiez un objet immuable, Python crée en réalité un nouvel objet en mémoire :

x = 10
print(id(x))  # Ex: 140234866477328

x += 1
print(id(x))  # Ex: 140234866477360 — nouvel objet !

Annotations de type (type hints)

Depuis Python 3.5, vous pouvez ajouter des annotations de type à vos variables. Elles ne changent pas le comportement du programme mais améliorent considérablement la lisibilité et permettent l'utilisation d'outils de vérification statique comme mypy.

# Annotations de type pour les variables
nom: str = "Alice"
age: int = 30
taille: float = 1.72
est_actif: bool = True

# Annotations avec des types composés
from typing import List, Dict, Optional, Tuple

notes: List[int] = [15, 18, 12]
utilisateur: Dict[str, str] = {"nom": "Alice", "ville": "Paris"}
resultat: Optional[int] = None
coordonnees: Tuple[float, float] = (48.8566, 2.3522)

Variables spéciales en Python

Python utilise certaines variables spéciales que vous rencontrerez fréquemment :

La variable __name__

La variable __name__ est une variable spéciale définie automatiquement par Python. Elle contient le nom du module en cours d'exécution :

# script.py
print(__name__)  # "__main__" si exécuté directement

if __name__ == "__main__":
    print("Ce script est exécuté directement")

La variable _

Le simple underscore _ est conventionnellement utilisé pour les valeurs que vous souhaitez ignorer :

# Ignorer une valeur dans un déballage
nom, _, age = ("Alice", "Dupont", 30)

# Ignorer l'index dans une boucle
for _ in range(5):
    print("Répétition")

Variables avec double underscore

Les variables entourées de doubles underscores (appelées dunder) sont des variables spéciales de Python comme __init__, __new__ ou __all__. Elles jouent un rôle fondamental dans le fonctionnement interne du langage.

Bonnes pratiques

Voici un récapitulatif des bonnes pratiques essentielles pour travailler avec les variables en Python :

• Utilisez des noms descriptifs : préférez nombre_etudiants à n ou x.
• Respectez le snake_case : c'est la convention Python (PEP 8) pour les noms de variables et de fonctions.
• Limitez la portée : évitez les variables globales autant que possible.
• Initialisez toujours vos variables : ne laissez jamais une variable sans valeur initiale.
• Utilisez les annotations de type : elles documentent votre code et aident les outils d'analyse.
• Évitez les noms de fonctions built-in : ne nommez jamais une variable list, dict, str, type, print ou len car cela masquerait la fonction native.
• Ajoutez des commentaires et des docstrings pour expliquer la raison d'être des variables complexes.
• Utilisez les constantes : pour les valeurs qui ne changent pas, utilisez des noms en MAJUSCULES.

# ✅ Code exemplaire
MAX_TENTATIVES = 3
nom_utilisateur: str = "Alice"
notes_etudiant: list[int] = [15, 18, 12, 20]

def calculer_moyenne(notes: list[int]) -> float:
    """Calcule la moyenne d'une liste de notes."""
    return sum(notes) / len(notes)

moyenne = calculer_moyenne(notes_etudiant)
print(f"Moyenne de {nom_utilisateur} : {moyenne:.2f}")

Questions fréquentes

En Python, il n'existe pas de véritable constante au sens strict du terme. Par convention, les valeurs qui ne doivent pas être modifiées sont écrites en MAJUSCULES (par exemple PI = 3.14159). Cependant, rien n'empêche techniquement de les modifier. C'est une convention que tous les développeurs Python respectent pour indiquer qu'une variable ne devrait pas être changée.

Oui, vous pouvez supprimer une variable avec le mot-clé del. Une fois supprimée, toute tentative d'accès à cette variable provoquera une NameError :

x = 42
print(x)  # 42

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

Cependant, la suppression explicite de variables est rarement nécessaire. Le ramasse-miettes (garbage collector) de Python se charge automatiquement de libérer la mémoire des objets qui ne sont plus référencés.

Python offre une syntaxe élégante pour échanger les valeurs de deux variables sans avoir besoin d'une variable temporaire :

a = 10
b = 20

# Échange en une seule ligne
a, b = b, a

print(a)  # 20
print(b)  # 10

Cette syntaxe fonctionne grâce au mécanisme de déballage de tuple de Python. C'est l'une des particularités qui rendent le langage si agréable à utiliser.

Les variables sont le tout premier concept que vous devez maîtriser en Python. Pour acquérir une compréhension solide et progressive des variables ainsi que de tous les autres concepts du langage, nous vous recommandons de suivre notre formation dédiée à Python sur Believemy. Vous y apprendrez les bonnes pratiques, le typage, la gestion de la mémoire et bien plus encore à travers des exercices concrets.