Programmation Python/Variables

Un livre de Wikilivres.
Aller à : navigation, rechercher


Affectations[modifier | modifier le wikicode]

Début d’un principe
Fin du principe


En Python comme dans de nombreux autres langages, le symbole = est l'opérateur d'affectation. Cette valeur restera accessible jusqu'à la fin de l'exécution du programme (vérifiable avec "print(x)").

La valeur de la variable peut être un littéral, c'est-à-dire une constante, ou bien une expression (ex : une autre variable ou une instruction comme "1+1"). L'expression est évaluée avant d'être affectée à la variable.


Réaffectation[modifier | modifier le wikicode]

Si la variable affectée n'existe pas, l'ordinateur la crée, sinon il écrase sa valeur. En effet, il est permis de ré-affecter une nouvelle valeur à une même variable, autant de fois qu'on le souhaite.

>>> altitude = 320
>>> print(altitude)
320
>>> altitude = 375
>>> print(altitude)
375

Ceci nous amène à attirer votre attention sur le fait que le symbole égale utilisé sous Python pour réaliser une affectation ne doit en aucun cas être confondu avec un symbole d'égalité tel qu'il est compris en mathématique. Il est tentant d'interpréter l'instruction altitude = 320 comme une affirmation d'égalité, mais ce n'en n'est pas une !

  • Premièrement, l'égalité est commutative, alors que l'affectation ne l'est pas. Ainsi, en mathématique, les écritures a = 7 et 7 = a sont équivalentes, alors qu'une instruction de programmation telle que 375 = altitude serait illégale.
  • Deuxièmement, l'égalité est permanente, alors que l'affectation peut être remplacée comme nous venons de le voir. Lorsqu'en mathématique, nous affirmons une égalité telle que a = b au début d'un raisonnement, alors a continue à être égal à b durant tout le développement qui suit.

En programmation, une première instruction d'affectation peut rendre égales les valeurs de deux variables, et une instruction ultérieure en changer ensuite l'une ou l'autre. Exemple :

>>> a = 5
>>> b = a  # a et b contiennent des valeurs égales
>>> b = 2  # a et b sont maintenant différentes

Affectations multiples[modifier | modifier le wikicode]

Sous Python, on peut assigner une valeur à plusieurs variables simultanément. Exemple d'affectation multiple :

>>> x = y = 7
>>> x
7
>>> y
7

Affectations parallèles[modifier | modifier le wikicode]

On peut aussi effectuer des affectations parallèles à l'aide d'un seul opérateur :

>>> a, b = 4, 8.33
>>> a
4
>>> b
8.33
 les francophones ont pour habitude d'utiliser la virgule comme séparateur décimal, alors que les langages de programmation utilisent toujours la convention en vigueur dans les pays de langue anglaise, c'est-à-dire le point décimal. La virgule, quant à elle, est très généralement utilisée pour séparer différents éléments (arguments, etc.) comme on le voit dans notre exemple, pour les variables elles-mêmes ainsi que pour les valeurs qu'on leur attribue.

Exercices


  1. Décrivez le plus clairement et le plus complètement possible ce qui se passe à chacune des trois lignes de l'exemple ci-dessous :
    >>> largeur = 20
    >>> hauteur = 5 * 9.3
    >>> largeur * hauteur
    930.0
    
  2. Assignez les valeurs respectives 3, 5, 7 à trois variables a, b, c. Effectuez l'opération a - b/c . Le résultat est-il mathématiquement correct ? Si ce n'est pas le cas, comment devez-vous procéder pour qu'il le soit ?

Solution

Réfléchissez !

Principe de fonctionnement[modifier | modifier le wikicode]

L'essentiel du travail effectué par un programme d'ordinateur consiste à manipuler des données. Ces données peuvent être très diverses (tout ce qui est numérisable, en fait), mais dans la mémoire de l'ordinateur elles se ramènent toujours en définitive à une suite finie de nombres binaires.

Pour pouvoir accéder aux données, le programme d'ordinateur (quel que soit le langage dans lequel il est écrit) fait abondamment usage d'un grand nombre de variables de différents types.

Une variable apparaît dans un langage de programmation sous un nom de variable à peu près quelconque, mais pour l'ordinateur il s'agit d'une référence désignant une adresse mémoire, c'est-à-dire un emplacement précis dans la mémoire vive.

A cet emplacement est stocké une valeur bien déterminée. C'est la donnée proprement dite, qui est donc stockée sous la forme d'une suite de nombres binaires, mais qui n'est pas nécessairement un nombre aux yeux du langage de programmation utilisé. Cela peut être en fait à peu près n'importe quel « objet » susceptible d'être placé dans la mémoire d'un ordinateur, par exemple : un nombre entier, un nombre réel, un nombre complexe, un vecteur, une chaîne de caractères typographique, un tableau, une fonction, etc.

Exemple[modifier | modifier le wikicode]

Prenons l'exemple suivant :

>>> n = 7                       # donner à "n" la valeur "7"
>>> message = "Quoi de neuf ?"  # affecter la valeur "Quoi de neuf ?" à "message"
>>> pi = 3.14159                # assigner sa valeur à la variable "pi"

Les exemples ci-dessus illustrent des instructions d'affectation Python tout à fait classiques. Après qu'on les ait exécutées, il existe dans la mémoire de l'ordinateur, à des endroits différents :

  • trois noms de variables, à savoir "n", "message" et "pi" ;
  • trois séquences d'octets, où sont encodées le nombre entier "7", la chaîne de caractères "Quoi de neuf ?" et le nombre réel "3,14159".

Les trois instructions d'affectation ci-dessus ont eu pour effet chacune de réaliser plusieurs opérations dans la mémoire de l'ordinateur :

  • créer et mémoriser un nom de variable ;
  • lui attribuer un type bien déterminé ;
  • créer et mémoriser une valeur particulière ;
  • établir un lien (par un système interne de pointeurs) entre le nom de la variable et l'emplacement mémoire de la valeur correspondante.

On peut mieux se représenter tout cela par un diagramme d'état tel que celui-ci :

n message pi
7 Quoi de neuf ? 3.14159

Les trois noms de variables sont des références, mémorisées dans une zone particulière de la mémoire que l'on appelle espace de noms, alors que les valeurs correspondantes sont situées ailleurs, dans des emplacements parfois fort éloignés les uns des autres.

Les références[modifier | modifier le wikicode]

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é.

L'utilisation des références
>>> 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érence à 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.

Indépendances des variables
>>> 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]

Idem pour les nombres :

Références et nombres
>>> a = 5
>>> b = a
>>> print (a)
5
>>> print (b)
5
>>> b += 5
>>> print (b)
10
>>> print (a)
5


Noms des variables[modifier | modifier le wikicode]

Les noms de variables sont des noms que vous choisissez vous-même assez librement. Efforcez-vous cependant de bien les choisir : de préférence assez courts, mais aussi explicites que possible, de manière à exprimer clairement ce que la variable est censée contenir. Par exemple, des noms de variables tels que "longitude" et "latitude" conviennent mieux que "x" et "y", car un bon programmeur doit veiller à ce que ses lignes d'instructions soient faciles à lire.

Sous Python, les noms de variables doivent en outre obéir à quelques règles simples :

  • Un nom de variable est une séquence de lettres (a → z , A → Z) et de chiffres (0 → 9), qui doit toujours commencer par une lettre.
  • La casse est significative (les caractères majuscules et minuscules sont distingués). Donc "Joseph", "joseph", et "JOSEPH" sont des variables différentes.
  • les 29 « mots réservés » du langage sont déjà pris (ex : "print").
  • Seules les lettres du code ASCII sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @, etc. sont interdits, à l'exception du caractère _ (souligné).
 sous Python 3 les règles de nommage ont étés assouplies, car il devient possible d'utiliser n'importe quel caractère Unicode non opérateur dans les noms.

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ée objet.
Les noms suivants ne peuvent pas être utilisés comme nom de variable
 41toto  # On ne commence pas par un chiffre
 élément # Contient un caractère accentué, qui ne sont pas autorisés

De plus, il est recommandé d'écrire les noms de variables avec une minuscule, car l'usage veut qu'on le réserve plutôt la majuscule aux noms de classes.

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

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

Il convient aussi 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, mais cela alourdit très fortement le programme. On pourra par exemple s'inspirer de la notation hongroise qui formalise ce mécanisme.

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


Références[modifier | modifier le wikicode]