Affectation

Cas d'une constante

La constante peut être d'un type quelconque : entier, réel, booléen, chaîne de caractères, tableau, matrice, dictionnaire... comme le suggèrent les exemples ci-dessous.

En Python, la valeur que l'on affecte à une variable impose dynamiquement le type de la variable (Table Principaux types de base en Python). Ainsi, si l'on affecte la valeur 3.14 à la variable x : x = 3.14, celle-ci dénote alors un réel (type float en Python); si par contre, on lui affecte la valeur 'salut': x = 'salut', elle dénote alors une chaîne de caractères (type str en Python).

Cas d'une expression

L'expression peut être n'importe quelle expression évaluable telle qu'une opération logique : True or False and not True, une opération arithmétique : 3 + 2*9 - 6*7, un appel de fonction : sin(x) ou toute autre combinaison évaluable : (x != y) and (z + t >= y) or (sin(x) < 0).

L'expression du membre de droite peut faire intervenir la variable du membre de gauche comme dans i = i+1. Dans cet exemple, on évalue d'abord le membre de droite i+1 puis on attribue la valeur obtenue au membre de gauche i; ainsi, à la fin de cette affectation, la valeur de i a été augmentée de 1 : on dit que i a été incrémenté de 1 et on parle d'incrémentation de la variable i. Le langage Python propose un opérateur d'incrémentation += et d'autres opérateurs d'affectation qui peuvent toujours se ramener à l'utilisation de l'opérateur =, l'opérateur d'affectation de base.

Une instruction pas si simple que ça

L'affectation a donc pour effet de réaliser plusieurs opérations en mémoire :

• créer et mémoriser une valeur particulière,
• créer et mémoriser un nom de variable,
• é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,
• attribuer un type déterminé à la variable.

Exemples

Méthode

Pour déterminer les valeurs de variables après une séquence d'instructions, il faut suivre instruction après instruction (pas à pas) l'évolution des valeurs des variables concernées.

Il s'agit donc de suivre l'évolution des valeurs de \(r\) variables \(v_1, v_2, \ldots, v_r\) qui interviennent dans une séquence de \(n\) instructions \(i_1, i_2, \ldots, i_n\).

Pour suivre pas à pas (instruction par instruction) l'évolution des variables, on dresse un tableau où chaque ligne \(k\) correspond à une instruction \(i_k\) et chaque colonne \(j\) à une variable \(v_j\). Pour chaque instruction \(i_k\), on indique la valeur \(x_{k,j}\) que prend chaque variable \(v_j\) après exécution de l'instruction \(i_k\).

Si une variable n'a pas encore été initialisée au moment où on exécute une instruction, on lui donne pour valeur le ? indiquant ainsi qu'on ne connaît pas encore sa valeur. On trouve dans la dernière ligne \(n\) du tableau, les valeurs finales \(x_{n,1}, x_{n,2}, \ldots, x_{n,r}\) des \(r\) variables \(v_1, v_2, \ldots, v_r\).

Ainsi, cette méthode de l'empathie numérique donne les résultats suivants pour les deux exemples précédents :

Vérification

Lorsque le code est une donnée de l'énoncé, comme c'est le cas dans les 2 exercices précédents, une technique de vérification « évidente » consiste à le faire exécuter directement par l'interpréteur Python.

Pour suivre pas à pas l'exécution de la séquence d'affectations tel que le préconise la méthode de l'empathie numérique, nous reprenons le code proposé et, après chaque instruction, nous affichons les valeurs des variables qui interviennent dans ce code.

L'exécution par Python des séquences précédentes donne bien les mêmes résultats que ceux que nous avons obtenus « à la main ».

Version 1

Un apprenti informaticien à qui on demandait d'échanger (swap) les valeurs de 2 variables x et y proposa la suite d'instructions suivante:

x = 10
y = 20
x = y
y = x

Il eut la désagréable surprise de constater que les valeurs des variables n'étaient pas permutées après cette séquence d'affectations. En effet, les variables sont respectivement initialisées par les instructions x = 10 et y = 20. L'affectation x = y conduit à évaluer y puis à attribuer la valeur de y (20) à x : x vaut maintenant 20. La deuxième affectation y = x commence par évaluer x puis à attribuer la valeur de x (20) à y : y vaut maintenant 20. Après ces 2 affectations, les valeurs de x et y sont donc identiques (et égales à 20) et non permutées!

python : affectation-swap-1.py

Le problème de cette version vient du fait que la valeur initiale (10) de x n'est plus référencée et donc... qu'on ne peut plus y faire référence.

Version 2

Pour effectuer la permutation, l'apprenti informaticien aurait pu utiliser une variable temporaire tmp pour référencer la valeur initiale de x et exécuter la séquence d'instructions suivante:

x = 10
y = 20
tmp = x
x = y
y = tmp

La première affectation (tmp = x) permet de stocker la valeur initiale de x (10), la deuxième (x = y) attribue à x la valeur de y (20) et la troisième (y = tmp) attribue à y la valeur de tmp, c'est-à-dire la valeur initiale de x (10). Ainsi, les valeurs finales de x et y (20 et 10) sont bien permutées par rapport aux valeurs initiales (10 et 20).

python : affectation-swap-2.py

Version 3

En Python, les n-uplets permettent d'écrire plus simplement la permutation de deux variables : x, y = y, x:

x = 10
y = 20
x, y = y, x

On commence par évaluer le membre de droite, soit la paire y,x qui vaut 20,10; puis on attribue cette valeur au membre de gauche, soit à la paire x,y qui vaut donc après affectation 20,10. Ainsi, le premier élément x de la paire x,y vaut maintenant 20 et le second argument y vaut 10. Les valeurs de x et de y ont dont bien été échangées par l'affectation x, y = y, x.

python : affectation-swap-3.py

Généralisation

On peut utiliser la même technique (version 2 ou version 3) pour échanger des valeurs entre plus de 2 variables comme l'illustrent les 2 exercices suivants.

u, v, w = 1, 2, 3
u, v, w = w, u, v

u, v, x, y, z = 1, 2, 3, 4, 5
u, v, x, y, z = v, x, y, z, u

Les exemples précédents de séquences d'affectation illustrent la possibilité de réaliser des calculs plus ou moins compliqués à l'aide d'une séquence d'affectations bien choisies. Mais ce sont les alternatives et les itérations qui permettront d'aborder des algorithmes plus complexes, tout en améliorant l'expressivité des programmes.