[wiki: Affectation] [#license ©]
Pour essayer les exemples, vous pouvez utiliser le Online Python Tutor.
Variables et valeurs
- La première affectation à un nouvelle variable crée cette variable et la valeur correspondante.
- Il faut visualiser variable et valeur comme deux entités différentes, la première désignant la seconde (plutôt que la contenant).
- Les affectations suivantes font que la variable existante désigne une autre valeur.
- Le type est attaché à la valeur (et non pas à la variable).
- Les valeurs qui ne sont plus désignées sont récupérées par le ramasse-miette automatique.
- PROGRAMMEURS C/C++, ATTENTION DANGER : il ne s’agit ni vraiment de variables ordinaires, ni vraiment de pointeurs…
#!comment
A REFAIRE : tous les diagrammes en mettant des nombres flottants.
(le partage automatique des valeurs entières est une exception
qui ne doit pas être mise en avant).
Pour les programmeurs C++, on peut voir les noms de python comme des pointeurs no typés (void *), mais qui sont automatiquement déréférencés quand on les utilise.
Ce sont les objets qui sont typés, et en réalité chaque objet est précédé en mémoire de deux entêtes :
- son type
- son compteur de références
Les objets qui ne sont plus pointés sont automatiquement récupérés par le ramasse-miette.On peut éliminés explicitement un nom avec le mot-réservé "del".
>>> a = 3
>>> a = 'hello'
>>> a = 1.23#!html
<br clear=right>Partage de valeurs
#!python
>>> a = 3
>>> b = a
>>> a = 'hello'
>>> a = b+2
>>> c = 3
#!html
<br clear=right>Modification d’un élément de collection
#!python
>>> l1 = [2,3,4]
>>> l2 = l1
>>> l1[0] = 5
#!html
<br clear=right>Forcer la duplication à l’aide d’une « tranche complète »
#!python
>>> l1 = [2,3,4]
>>> l2 = l1[:]
>>> l2[1] = 6
#!html
<br clear=right>Copie superficielle et profonde
- La duplication d’une séquence en faisant une tranche complète (
[:]) ne fonctionne pas avec les associations (dictionnaires et ensembles). Une procédure valable pour toutes les collections, y compris les associations, consiste à utiliser la méthodecopy()du modulecopy. - ATTENTION : cette façon de copier est « superficielle », c’est à dire qu’elle ne duplique que la structure de plus haut niveau, et ne duplique pas les éléments interne de la collection. Dans le cas de collections imbriquées, cela peut poser problème.
- Pour dupliquer de façon récursive une collection et tous ses éléments, utilisez
deepcopy().
#!python
>>> import copy
>>> l1 = [2,3,4]
>>> l2 = copy.copy(l1)
>>> l2[1] = 6
>>> print l1
[2,3,4]
>>> print l2
[2,6,4]
>>> import copy
>>> l1 = [1, [2,3,4], 5]
>>> l2 = copy.copy(l1)
>>> l2[1][1] = 6
>>> print l1
[1, [2,6,4], 5]
>>> print l2
[1, [2,6,4], 5]
>>> import copy
>>> l1 = [1, [2,3,4], 5]
>>> l2 = copy.deepcopy(l1)
>>> l2[1][1] = 6
>>> print l1
[1, [2,3,4], 5]
>>> print l2
[1, [2,6,4], 5]
#!html
<br clear=right>Egalité et identité
#!python
>>> l1 = [2,3,4]
>>> l2 = l1
>>> l1==l2
True
>>> l1 is l2
True
#!html
<br clear=right>
#!python
>>> l1 = [2,3,4]
>>> l2 = [2,3,4]
>>> l1==l2
True
>>> l1 is l2
False
#!html
<br clear=right>
#!python
>>> x = 42.5
>>> y = 42.5
>>> x==y
True
>>> x is y
False
#!html
<br clear=right>
Dans le cas précis des int, pour éviter de recréer de multiples instances des mêmes petits entiers, Python réutilise une seule et même valeur quand c’est possible.
#!python
>>> x = 42
>>> y = 42
>>> x==y
True
>>> x is y
True
ATTENTION DANGER : is est peut-être beaucoup plus rapide que == dans certaines circonstances, mais c’est un faux ami qui expose des mécanismes interne de Python ; à utiliser avec précaution pour les collections, quand les performances l’exige ; à éviter pour les valeurs numériques scalaires.
#!html
<br clear=right>Passage d’arguments
Suite à un appel de fonction, les paramètres désignent les mêmes valeurs que les variables données en argument.
Modifier un paramètre n’affecte pas la variable extérieure.
Modifier un élément de ce paramètre, si il désigne uen collection modifiable, affectera la variable extérieure qui désigne la même collection.
#!python
>>> def changer(a,b):
... a = 2
... b[0] = 'hello'
...
>>> x = 1
>>> y = [1,2]
>>> changer(x,y) # a,b = x,y
>>> x,y
(1,['hello',2])
#!html
<br clear=right>Affectation dans une fonction
ATTENTION DANGER : dans une fonction, toute affectation à une variable qui n’est pas un paramètre, entraine la création d’une variable locale à la fonction, sauf si il s’agit d’un élément de collection modifiable.
#!python
>>> x = 88
>>> y = [ 1, 2 ]
>>> def func():
... x = 99
... y[0] = 0
...
>>> func()
>>> x, y
( 88, [0,2] )#!html
<br clear=right>Résumé
- Les types sont attachés aux valeurs, pas aux variables.
- Chaque valeur est rendue au système quand elle n’est plus désignée par aucune variable.
- La modification d’un élément de collection affecte toutes les variables désignant cette collection.
- Le passage des arguments d’une fonction se fait par affectation à des variables locales.
- Les affectations au sein des fonctions créent des variables locales.
#!comment
A la différence de C++, qui distingue
- variables ordinaires, références, pointeurs.
- passage d'arguments par valeur, référence, pointeur.
#!html
<br clear=right>Quiz
1. Quelle est la valeur finale retournée par a ?
#!python
>>> a = "hello"
>>> b = a
>>> b = "world"
>>> a1. Quelle est la valeur finale retournée par a ?
#!python
>>> a = [ "hello" ]
>>> b = a
>>> b[0] = "world"
>>> a1. Quelle est la valeur finale retournée par a ?
#!python
>>> a = [ "hello" ]
>>> b = a[:]
>>> b[0] = "world"
>>> a1. Quelle est la valeur finale retournée par a ?
#!python
>>> def f(x):
... x = "world"
...
>>> a = "hello"
>>> f(a)
>>> a1. Quelle est la valeur finale retournée par a ?
#!python
>>> def f(x):
... x[0] = "world"
...
>>> a = [ "hello" ]
>>> f(a)
>>> a© David Chamont, Laboratoire Leprince-Ringuet (LLR) / IN2P3 / CNRS, Ecole polytechnique / Université Paris-Saclaybr
© Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution – Partage dans les Mêmes Conditions 4.0 International [=#license]