Variables en Python

Dans le didacticiel précédent surBasic Data Types in Python, vous avez vu comment les valeurs de divers types de données Python peuvent être créées. Mais jusqu'à présent, toutes les valeurs affichées ont été des valeurs littérales ou constantes:

>>>

>>> print(5.3)
5.3

Si vous écrivez du code plus complexe, votre programme aura besoin de données qui peuvent changer au fur et à mesure de l'exécution du programme.

Here’s what you’ll learn in this tutorial: Vous apprendrez comment chaque élément de données d'un programme Python peut être décrit par le terme abstraitobject, et vous apprendrez à manipuler des objets à l'aide de noms symboliques appelésvariables.

Téléchargement PDF gratuit: Aide-mémoire Python 3

__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Variables Python». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

Fais le quiz "

Affectation variable

Considérez une variable comme un nom attaché à un objet particulier. En Python, les variables n'ont pas besoin d'être déclarées ou définies à l'avance, comme c'est le cas dans de nombreux autres langages de programmation. Pour créer une variable, il vous suffit de lui attribuer une valeur, puis de commencer à l'utiliser. L'affectation se fait avec un seul signe égal (=):

>>>

>>> n = 300

Ceci est lu ou interprété comme «n reçoit la valeur300.» Une fois que cela est fait,n peut être utilisé dans une instruction ou une expression, et sa valeur sera remplacée:

>>>

>>> print(n)
300

Tout comme une valeur littérale peut être affichée directement à partir de l'invite de l'interpréteur dans une session REPL sans avoir besoin deprint(), une variable peut également:

>>>

>>> n
300

Plus tard, si vous modifiez la valeur den et que vous l'utilisez à nouveau, la nouvelle valeur sera remplacée à la place:

>>>

>>> n = 1000
>>> print(n)
1000
>>> n
1000

Python permet également l'affectation chaînée, ce qui permet d'affecter la même valeur à plusieurs variables simultanément:

>>>

>>> a = b = c = 300
>>> print(a, b, c)
300 300 300

L'affectation chaînée ci-dessus affecte300 aux variablesa,b etc simultanément.

Types de variables en Python

Dans de nombreux langages de programmation, les variables sont typées statiquement. Cela signifie qu'une variable est initialement déclarée avoir un type de données spécifique et que toute valeur qui lui est affectée pendant sa durée de vie doit toujours avoir ce type.

Les variables en Python ne sont pas soumises à cette restriction. En Python, une variable peut se voir attribuer une valeur d'un type puis réattribuer ultérieurement une valeur d'un type différent:

>>>

>>> var = 23.5
>>> print(var)
23.5

>>> var = "Now I'm a string"
>>> print(var)
Now I'm a string

Références d'objets

Que se passe-t-il réellement lorsque vous effectuez une affectation de variable? Il s'agit d'une question importante en Python, car la réponse diffère quelque peu de ce que vous trouverez dans de nombreux autres langages de programmation.

Python est hautementobject-oriented language. En fait, pratiquement chaque élément de données dans un programme Python est un objet d'un type ou d'une classe spécifique. (Ce point sera répété plusieurs fois au cours de ces didacticiels.)

Considérez ce code:

>>>

>>> print(300)
300

Lorsqu'on lui présente l'instructionprint(300), l'interpréteur effectue les opérations suivantes:

Crée un objet entier
Lui donne la valeur300
L'affiche sur la console

Vous pouvez voir qu'un objet entier est créé à l'aide de la fonction intégréetype():

>>>

>>> type(300)

Une variable Python est un nom symbolique qui est une référence ou un pointeur vers un objet. Une fois qu'un objet est affecté à une variable, vous pouvez vous référer à l'objet par ce nom. Mais les données elles-mêmes sont toujours contenues dans l'objet.

Par exemple:

>>>

>>> n = 300

Cette affectation crée un objet entier avec la valeur300 et affecte la variablen pour qu'elle pointe vers cet objet.

Le code suivant vérifie quen pointe vers un objet entier:

>>>

>>> print(n)
300
>>> type(n)

Considérez maintenant l'énoncé suivant:

>>>

>>> m = n

Que se passe-t-il lors de son exécution? Python ne crée pas d'autre objet. Il crée simplement un nouveau nom ou référence symbolique,m, qui pointe vers le même objet vers lequel pointen.

Ensuite, supposez que vous fassiez ceci:

>>>

>>> m = 400

Maintenant, Python crée un nouvel objet entier avec la valeur400, etm devient une référence à celui-ci.

Enfin, supposons que cette instruction soit exécutée ensuite:

>>>

>>> n = "foo"

Maintenant, Python crée un objet chaîne avec la valeur"foo" et fait référence àn.

Il n'y a plus de référence à l'objet entier300. Il est orphelin et il n'y a aucun moyen d'y accéder.

Les didacticiels de cette série font parfois référence à la durée de vie d'un objet. La vie d'un objet commence lors de sa création, moment auquel au moins une référence à celui-ci est créée. Pendant la durée de vie d'un objet, des références supplémentaires à celui-ci peuvent être créées, comme vous l'avez vu ci-dessus, et les références à celui-ci peuvent également être supprimées. Un objet reste vivant, pour ainsi dire, tant qu'il y a au moins une référence à lui.

Lorsque le nombre de références à un objet tombe à zéro, il n'est plus accessible. À ce stade, sa durée de vie est terminée. Python finira par remarquer qu'elle est inaccessible et récupérera la mémoire allouée afin qu'elle puisse être utilisée pour autre chose. Dans le jargon informatique, ce processus est appelégarbage collection.

Identité d'objet

En Python, chaque objet créé reçoit un numéro qui l'identifie de manière unique. Il est garanti que deux objets n'auront pas le même identifiant au cours d'une période où leurs durées de vie se chevauchent. Une fois que le nombre de références d'un objet tombe à zéro et qu'il est récupéré, comme cela est arrivé à l'objet300 ci-dessus, son numéro d'identification devient disponible et peut être réutilisé.

La fonction Python intégréeid() renvoie l'identifiant entier d'un objet. En utilisant la fonctionid(), vous pouvez vérifier que deux variables pointent bien vers le même objet:

>>>

>>> n = 300
>>> m = n
>>> id(n)
60127840
>>> id(m)
60127840

>>> m = 400
>>> id(m)
60127872

Après l'affectationm = n,m etn pointent tous les deux vers le même objet, confirmé par le fait queid(m) etid(n) renvoient le même nombre. Une fois quem est réaffecté à400,m etn pointent vers différents objets avec des identités différentes.

Deep Dive: mise en cache de petites valeurs entières

D'après ce que vous savez maintenant sur l'affectation des variables et les références d'objet en Python, les éléments suivants ne vous surprendront probablement pas:

>>>
>>> m = 300
>>> n = 300
>>> id(m)
60062304
>>> id(n)
60062896
Avec l'instructionm = 300, Python crée un objet entier avec la valeur300 et définitm comme référence à celui-ci. n est alors affecté de manière similaire à un objet entier avec la valeur300 - mais pas le même objet. Ainsi, ils ont des identités différentes, que vous pouvez vérifier à partir des valeurs renvoyées parid().

Mais considérez ceci:

>>>
>>> m = 30
>>> n = 30
>>> id(m)
1405569120
>>> id(n)
1405569120
Ici,m etn sont affectés séparément aux objets entiers ayant la valeur30. Mais dans ce cas,id(m) etid(n) sont identiques!

À des fins d'optimisation, l'interpréteur crée des objets pour les entiers dans la plage[-5, 256] au démarrage, puis les réutilise pendant l'exécution du programme. Ainsi, lorsque vous affectez des variables distinctes à une valeur entière dans cette plage, elles référencent en fait le même objet.

Noms de variables

Les exemples que vous avez vus jusqu'à présent ont utilisé des noms de variables courts et concis commem etn. Mais les noms de variables peuvent être plus verbeux. En fait, cela est généralement bénéfique s'ils le sont, car cela rend le but de la variable plus évident à première vue.

Officiellement, les noms de variables en Python peuvent être de n'importe quelle longueur et peuvent être constitués de lettres majuscules et minuscules (A-Z,a-z), de chiffres (0-9) et du caractère de soulignement (_). Une restriction supplémentaire est que, bien qu'un nom de variable puisse contenir des chiffres, le premier caractère d'un nom de variable ne peut pas être un chiffre.

Note: L'un des ajouts à Python 3 était la prise en charge complète d'Unicode, qui autorise également les caractères Unicode dans un nom de variable. Vous en apprendrez plus sur Unicode dans un futur tutoriel.

Par exemple, tous les éléments suivants sont des noms de variable valides:

>>>

>>> name = "Bob"
>>> Age = 54
>>> has_W2 = True
>>> print(name, Age, has_W2)
Bob 54 True

Mais celui-ci ne l'est pas, car un nom de variable ne peut pas commencer par un chiffre:

>>>

>>> 1099_filed = False
SyntaxError: invalid token

Notez que le cas est significatif. Les lettres minuscules et majuscules ne sont pas identiques. L'utilisation du caractère de soulignement est également importante. Chacun des éléments suivants définit une variable différente:

>>>

>>> age = 1
>>> Age = 2
>>> aGe = 3
>>> AGE = 4
>>> a_g_e = 5
>>> _age = 6
>>> age_ = 7
>>> _AGE_ = 8

>>> print(age, Age, aGe, AGE, a_g_e, _age, age_, _AGE_)
1 2 3 4 5 6 7 8

Rien ne vous empêche de créer deux variables différentes dans le même programme appelésage etAge, ou d'ailleursagE. Mais c'est probablement mal avisé. Cela pourrait certainement dérouter quiconque essaie de lire votre code, et même vous-même, après un certain temps.

Il vaut la peine de donner à une variable un nom suffisamment descriptif pour préciser à quoi elle sert. Par exemple, supposons que vous calculez le nombre de personnes qui ont obtenu leur diplôme collégial. Vous pouvez éventuellement choisir l'une des options suivantes:

>>>

>>> numberofcollegegraduates = 2500
>>> NUMBEROFCOLLEGEGRADUATES = 2500
>>> numberOfCollegeGraduates = 2500
>>> NumberOfCollegeGraduates = 2500
>>> number_of_college_graduates = 2500

>>> print(numberofcollegegraduates, NUMBEROFCOLLEGEGRADUATES,
... numberOfCollegeGraduates, NumberOfCollegeGraduates,
... number_of_college_graduates)
2500 2500 2500 2500 2500

Tous sont probablement de meilleurs choix quen, ouncg, ou autres. Au moins, vous pouvez dire à partir du nom ce que la valeur de la variable est censée représenter.

D'un autre côté, ils ne sont pas tous nécessairement également lisibles. Comme pour beaucoup de choses, c'est une question de préférence personnelle, mais la plupart des gens trouveraient les deux premiers exemples, où les lettres sont toutes regroupées, plus difficiles à lire, en particulier celui dans toutes les majuscules. Les méthodes les plus couramment utilisées pour construire un nom de variable multi-mots sont les trois derniers exemples:

Camel Case: Le deuxième mot et les suivants sont en majuscules, pour rendre les limites des mots plus faciles à voir. (Vraisemblablement, cela a frappé quelqu'un à un moment donné que les majuscules éparpillées dans le nom de la variable ressemblent vaguement à des bosses de chameau.)
- Exemple:numberOfCollegeGraduates
Pascal Case: Identique à Camel Case, sauf que le premier mot est également en majuscule.
- Exemple:NumberOfCollegeGraduates
Snake Case: Les mots sont séparés par des traits de soulignement.
- Exemple:number_of_college_graduates

Les programmeurs débattent vivement, avec une ferveur surprenante, laquelle est préférable. Des arguments décents peuvent être avancés pour chacun d'eux. Utilisez celui des trois qui vous plaît le plus visuellement. Choisissez-en un et utilisez-le régulièrement.

Vous verrez plus tard que les variables ne sont pas les seules choses auxquelles on peut donner un nom. Vous pouvez également nommer des fonctions, des classes, des modules, etc. Les règles qui s'appliquent aux noms de variables s'appliquent également aux identificateurs, le terme plus général pour les noms donnés aux objets de programme.

LeStyle Guide for Python Code, également connu sous le nom dePEP 8, contientNaming Conventions qui répertorie les normes suggérées pour les noms de différents types d'objets. PEP 8 comprend les recommandations suivantes:

Snake Case doit être utilisé pour les fonctions et les noms de variables.
Pascal Case doit être utilisé pour les noms de classe. (PEP 8 appelle cela la convention «CapWords».)

Mots réservés (mots clés)

Il existe une autre restriction sur les noms d'identifiants. Le langage Python réserve un petit ensemble de mots clés qui désignent des fonctionnalités de langage spéciales. Aucun objet ne peut avoir le même nom qu'un mot réservé.

En Python 3.6, il y a 33 mots-clés réservés:

Mots-clés Python

Mots-clés Python
`False`	`def`	`if`	`raise`
`None`	`del`	`import`	`return`
`True`	`elif`	`in`	`try`
`and`	`else`	`is`	`while`
`as`	`except`	`lambda`	`with`
`assert`	`finally`	`nonlocal`	`yield`
`break`	`for`	`not`
`class`	`from`	`or`
`continue`	`global`	`pass`

False

def

if

raise

None

del

import

return

True

elif

in

try

and

else

is

while

as

except

lambda

with

assert

finally

nonlocal

yield

break

for

not

class

from

or

continue

global

pass

Vous pouvez voir cette liste à tout moment en tapanthelp("keywords") dans l'interpréteur Python. Les mots réservés sont sensibles à la casse et doivent être utilisés exactement comme indiqué. Ils sont tous entièrement minuscules, à l'exception deFalse,None etTrue.

Essayer de créer une variable avec le même nom que n'importe quel mot réservé entraîne une erreur:

>>>

>>> for = 3
SyntaxError: invalid syntax

Conclusion

Ce didacticiel a couvert les bases de Pythonvariables, y compris les références d'objet et l'identité, ainsi que la dénomination des identificateurs Python.

Vous avez maintenant une bonne compréhension de certains des types de données Python et savez comment créer des variables qui référencent des objets de ces types.

Ensuite, vous verrez comment combiner des objets de données enexpressions impliquant diversoperations.

Fais le quiz "

TOC

Variables en Python