Programmation Python/Variables
Affectations
[modifier | modifier le wikicode]
Pour les non-programmeursUne 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.
Cette opération est appelée "affectation" (ou "assignation"), et consiste à stocker une valeur en mémoire vive de l'ordinateur. On dit donc que l'on procède à l'affectation de la variable "x" avec la valeur "1".
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.
En Python les constantes sont déclarées et affectées comme les variables. La convention PEP8 leur impose juste un nom en majuscules[1].
Ex :
BASE_URL = "https://api.example.com"
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 est pas une !
- Premièrement, l'égalité est commutative, alors que l'affectation ne l'est pas. Ainsi, en mathématique, les écritures
a = 7et7 = asont équivalentes, alors qu'une instruction de programmation telle que375 = altitudeserait 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 = bau début d'un raisonnement, alorsacontinue à être égal àbdurant 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
Exercices
- 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
- 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 ?
Solution1.
>>> largeur = 20 # affecte la valeur 20 à largeur
>>> hauteur = 5 * 9.3 # affecte le résultat à hauteur
>>> largeur * hauteur # multiplie les 2 variables (largeur et hauteur)
930.0 # affiche le résultat de la multiplication des 2 variables
2.
>> a, b, c = 3, 5, 7 >>> a - b/c 2.2857142857142856 >> a - b//c # // : permet d'avoir un entier tronqué soit la b//c = 0 3
Ou plus avancé avec un import afin de l'avoir sous forme de fraction :
>> from fractions import * # Import du module fraction dans son ensemble
>>> a, b, c = 3, 5, 7
>>> print(a - Fraction(b/c)) # Appel de Fraction du module fractions
20587884010836553/9007199254740992
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.
À 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é.
>>> 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.
>>> 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 :
>>> 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é).
français = 1 est autorisé, mais pas f_en_€ = 6.55957.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.
41toto # On ne commence pas par un chiffre
élément # Contient un caractère accentué, qui ne sont pas autorisés sauf depuis Python 3
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.
Lister les variables
[modifier | modifier le wikicode]- Variables d'environnement :
print(os.environ)
- Variables globales :
print(globals())
- Variables locales :
print(locals())