Programmation Python/Variable

Un livre de Wikibooks.

Une variable est un espace mémoire dans lequel il est possible de mettre une valeur. Par exemple, si en français je dis x est égal à 1, j'utilise la variable dont le nom est x pour lui fixer la valeur 1. Pour faire la même chose en Python, je note simplement :

x=1

On dit que « je procéde à l'affectation de la variable x ». En Python, le symbole = est également nommé l'opérateur d'affectation.

[modifier] Création de variables

En Python, les variables sont crées automatiquement à leur première utilisation. Pour créer une variable, il suffit donc de l'utiliser en l'affectant une première fois, c'est à dire d'écrire nom_variable=valeur_de_la_variable.

La valeur de la variable peut être un litéral, c'est à dire une constante, ou bien une expression. L'expression est évaluée avant d'être affectée à la variable

x = 1 #On affecte la variable x avec la valeur du litéral 1
y = 1+1 #On affecte la variable y avec la valeur de l'expression 1 + 1 
z = x + y 

[modifier] Nom des variables

Une variable peut prendre n'importe quel nom, tant qu'elle respecte les règles suivantes :

• Son nom commence par une lettre minuscule (a à z) ou majuscule (A à Z), ou bien par le caractère souligné (_)
• Pour la suite de son nom, on peut utiliser les lettres minuscules et majuscule, le souligné et un chiffre (0 à 9)
• Son nom ne doit pas être un mot réservé.

 x
 X
 toto
 Toto
 _
 _toto
 _toto_

Il faut également noter que les variables dont le nom commence par le caractère _ ont une signification particulière :

• les noms commençant par un _ ne sont pas exportés lorsqu'ils se trouvent dans un module;
• les noms commençant par deux _ et finissant par deux _ sont réservés par le langage lui même, notamment pour la Programmation orienté objet.

Le nom des variables est sensible à la casse, ainsi toto et Toto ne désignent pas la même variable.

 41toto #On ne commence pas par un chiffre
 éric #Contient un caractère ''é'' qui n'est pas autorisé 

[modifier] Affectations

• simples

x=7

ici x = 7

• multiples

x=y=7

ici x et y = 7

• parallèles

x,y = 7,8

ici x=7 et y=8

[modifier] Conseil sur le nom des variables

En général, les noms de variables sont toujours en minuscule, la majuscule du début est souvent réservée pour les noms des classes. Pour nommer une variable il convient surtout de la nommer en fonction de ce qu'elle est censée faire ou représenter.

Ainsi, x, toto, A11, ne sont pas de bons noms de variable. Par contre hauteur, personne, cellule désignent mieux ce qu'elles sont censées représenter et aident un autre programmeur à comprendre ce qui a été fait.

Si le nom d'une variable doit comporter plusieurs mots, il y a deux possibilités d'écrire le nom de la variable :

• à la C, c'est à dire en séparant les mots par le caractère _ Exemple : marge_brut
• à la Java, c'est à dire en séparant les mots par un passage en haut de casse (lettre majuscule). Exemple : margeBrut

Il est mieux d'éviter les abréviations : nb pour nombre, h au lieu de hauteur, etc. Il convient également d'éviter autant que possible l'énumération de variables (toto1, toto2, toto3, ...), cela rend le programme parfaitement incompréhensible et sujet à des erreurs.

Il est possible de préfixer le nom de la variable par son type. Par exemple int_margeBrut, str_message_de_bienvenue. Cela alourdit très fortement le programme. On pourra par exemple s'inspirer de la notation hongroise qui formalise ce mécanisme.

D'autres notations existent ou peuvent être imposées en fonction d'un projet, des habitudes d'une entreprise, etc.

[modifier] Les références

Formellement, les variables Python sont des références, c'est à dire que écrire a = ((1,0,0),(0,1,0),(0,0,1)) ne signifie pas que a vaut ((1,0,0),(0,1,0),(0,0,1)) mais que a référence le n-uplet ((1,0,0),(0,1,0),(0,0,1)). La différence est que ensuite, une autre variable peut référencer le même n-uplet, simplement avec b = a. Si on modifie b, alors a sera également modifié.

>>> a = [(1,0,0), (0,1,0), (0,0,1)]
>>> b = a
>>> print a
[(1,0,0), (0,1,0), (0,0,1)]
>>> print b
[(1,0,0), (0,1,0), (0,0,1)]
>>> b[0] = (1,1,0)
>>> print b
[(1,1,0), (0,1,0), (0,0,1)]
>>> print a
[(1,1,0), (0,1,0), (0,0,1)]

Notez que a et b ne sont pas "liés", ils référencent simplement le même objet. Si ensuite on fait référencer à a un nouvel objet (par l'intermédiaire de l'opérateur d'affectation "="), b référencera toujours l'ancien objet, et une modification de l'un des objets ne modifiera pas l'autre.

>>> a = [1,2,3]
>>> b = a
>>> print a
[1,2,3]
>>> print b
[1,2,3]
>>> a = [4,5,6]
>>> print b
[1,2,3]
>>> print a
[4,5,6]
>>> a.append(7)
>>> print a
[4,5,6,7]
>>> print b
[1,2,3]

Notez enfin que ceci ne fonctionne pas pour les nombres:

>>> a = 5
>>> b = a
>>> print a
5
>>> print b
5
>>> b += 5
>>> print b
10
>>> print a
5

<< Page précédente: Structure d'un programme | Sommaire général | Page suivante: Type >>