Utilisation des variables

Une variable représente donc une case mémoire dans lequel on peut stocker une valeur d’un type donné.

Une variable possède :

— un nom choisi par le programmeur, — un type de contenu :int, float, etc.

— une valeur qui correspond au contenu de la case mémoire associée à la variable. Le nom de la variable permet de référencer la valeur contenue dans la variable. Les quatre principales manipulations liées aux variables sont les suivantes :

1. la déclaration de variable

2. l’initialisation de variable ou première affectation 3. l’occurrence de variable au sein d’une expression 4. sa mise à jour ou réaffectation.

3.2.2.1 Déclaration de variable Pour pouvoir être utilisée, une variable doit préalablement être déclarée.

La syntaxe utilisée pour une telle déclaration est la suivante : # <var> : <type>

où <var> est un nom de variable et <type> le type du contenu de la variable (int, float, etc.). Par exemple, dans la fonctionaire_triangle, nous avons effectué la déclaration suivante :

# p : float

On a ici déclaré une variable de nom p et de type float.

Il s’agit donc, en quelque sorte, de spécifier la signature de la variable.

3.2.2.2 Initialisation de variable Une variable n’existe pas «encore» après sa déclaration. Pour la créer, il faut impérativement préciser son contenu initial.

L’initialisation de la variable se fait juste en dessous de sa déclaration. La syntaxe pour initaliser une variable est la suivante :

# <var> : <type> <var> = <expression>

où <var> est un nom de variable dont le contenu doit être de type <type> et <expression> est une expression dont le type doit également être<type>.

La définition de la variable est donc la succession de la déclaration et de l’initialisation de cette variable.

Par exemple, dans la fonction aire_triangle, nous avons défini la variable p de la façon suivante :

# p : float

p = (a + b + c) / 2

On a ainsi précisé que l’on déclarait la variable de nomp, dont le contenu serait de type float, et on a initialisé son contenu avec le résultat du calcul de(a + b + c) / 2.

On remarque ici que l’expression utilisée pour cette initialisation est une division flottante. Elle est donc bien du même typefloat que celui déclaré pour la variable p.

Important : à une exception près (les variables d’itération que nous aborderons au cours 4), toutes les variables nécessaires doivent être déclarées au début du corps de la fonction : juste en dessous de la spécification et avant l’implémentation proprement dite de l’algorithme de calcul. Ainsi la structure usuelle d’une fonction est la suivante :

def ma_fonction(param1, param2, ...):

"""partie 1 : specification ..."""

# partie 2 : déclaration et initialisation des variables # v1 : type1 v1 = expr1 # v2 : type2 v2 = expr2 ... # vn : typeN vn = exprN

# partie 3 : algorithme de calcul

instruction1 instruction2 ... etc ...

3.2.2.3 Occurrence d’une variable dans une expression Après sa déclaration et son initialisation, une variable peut être utilisée dans les expressions de calcul. Il suffit pour cela d’indiquer le nom de la variable dans l’expression. On dit que l’expression contient une occurrence de la variable.

(p - a)

contient une occurrence de la variablep (ainsi qu’une occurrence du paramètre a). De même, l’expression :

math.sqrt(p * (p - a) * (p - b) * (p - c)) contient quatre occurrences de la variablep.

Le principe d’évaluation d’une occurrence de variable <var> dans une expression est le suivant :

L’occurrence de la variable est remplacée par la valeur qu’elle contient.

Donc si la valeur de la variablep est 10, la valeur de l’expression atomique p est également 10. En fait cela fonctionne exactement comme une calculatrice à mémoire, il n’y a aucune surprise ici.

Remarque : le contenu d’une variable est une valeur et non une expression. Ainsi, si l’on demande plusieurs fois la valeur d’une même variable, il n’y a aucun calcul supplémentaire effectué.

Par exemple, dans la fonction aire_triangle corrigée précédemment, le calcul du demi- périmètre est effectué une fois pour toute au moment de l’initialisation de la variablep. Les quatre occurrences de la variablep dans l’expression du calcul de l’aire ne conduisent à aucun calcul supplémentaire du demi-périmètre.

3.2.2.4 Affectation et réaffectation de variable La syntaxe : <var> = <expression>

(que nous avons par exemple rencontrée dans l’initialisation d’une variable) est appelée une affectation de variable.

Le principe d’interprétation des affectations est le suivant : — on évalue tout d’abord l’<expression>

— on place la valeur obtenue à l’étape précédente comme contenu de la variable<var>. Par exemple, si on supposea=2, b=3 et c=5 alors l’initialisation :

p = (a + b + c) / 2

place comme contenu de la variablep la valeur 2+3+5₂ c’est-à-dire 10. A l’issue de cette initiali- sation, on pourra représenter explicitement la case mémoire correspondante de la façon suivante :

variable p valeur 10

Il y a deux types différents d’affectation :

— la première affectation qui correspond à l’initialisation de la variable. — une réaffectation qui consiste à mettre à jour le contenu de la variable.

Une variable ne possède pas de contenu avant sa première affectation (lors de son initialisation). En revanche, lors d’une réaffectation, on efface tout simplement le précédent contenu pour en stocker un nouveau.

Considérons la suite d’instructions suivante :

# n : int n = 0 # m : int m = 58 n = m -16 m = m + 1

Question : quels sont les contenus des variables n et m après interprétation de cette suite d’instructions ?

Pour répondre à cette question précisément, nous pouvons placer quelquesprint judicieux et décortiquer l’interprétation de cette suite d’instructions.

# n : int

n = 0

print("Initialisation de n :")

print(" n =", n)

# remarque : m n'existe pas encore # m : int m = 58 print("Initialisation de n :") print(" n =", n) print(" m =", m) n = m - 16

print("Mise à jour de n :")

print(" n =", n)

print(" m =", m) m = m + 1

print(" n =", n)

print(" m =", m)

Les affichages produits sont les suivants : Initialisation de n : n = 0 Initialisation de n : n = 0 m = 58 Mise à jour de n : n = 42 m = 58 Mise à jour de m : n = 42 m = 59

Lors de la première étape, la variable n est initialisée à la valeur 0, on peut donc la représenter ainsi :

variable n valeur 0

Bien sûr, la variablem n’existe pas encore à ce stade donc tenter de l’afficher conduirait à une erreur : # n : int n = 0 print("Initialisation de n :") print(" n =", n) print(" m =", m) Initialisation de n : n = 0 ---

NameError Traceback (most recent call last)

<ipython-input-25-a278aada65a5> in <module>()

3 print("Initialisation de n :")

4 print(" n =", n) ----> 5 print(" m =", m)

NameError: name 'm' is not defined

Lors de la seconde étape, la variable m est à son tour initialisée. Puisque les deux variables existent, la table variable/valeur possède désormais deux colonnes :

variable n m valeur 0 58

Désormais, les deux variables sont initialisées et possèdent donc une valeur, il devient possible de les référencer.

L’étape suivante est une nouvelle affectation de la variablen. Puisque cette variable possède déjà une valeur, il ne s’agit pas d’une initialisation mais d’une réaffectation dans le but de mettre à jour le contenu de la variable.

L’interprétation de : n = m - 16

procède ainsi :

1. l’expressionm - 16 est évaluée en premier.

— la valeur de la sous-expression atomiquem est 58 : la valeur de la variable m — la valeur de l’expression complète est donc 58 − 16 soit 42

2. la valeur obtenue - donc 42 - est placée comme nouveau contenu de la variablen. La table des variables devient donc :

variable n m valeur 42 58

Selon les mêmes principes, la table des variables après la dernière instruction de réaffectationm = m + 1 est la suivante :

variable n m valeur 42 59

Tout se passe donc comme si nous avions «ajouté» 1 au contenu de la variablem. Mais si l’on veut être précis, il faut plutôt dire que : - nous avons d’abord récupéré la valeur dem, - puis nous avons calculé58 + 1, donc 59, - et nous avons stocké cette valeur 59 comme nouvelle valeur de la variablem.

Remarque : ajouter ou retrancher 1 d’une variable entière est si courant que l’on donne un nom spécifique à ces opérations :

— une expression de la formev = v + 1 où v est une variable (de type int) se nomme une incrémentation de la variablev

— une expression de la formev = v - 1 où v est une variable (de type int) se nomme une décrémentation de la variablev

3.2.2.5 Complément : règles de base concernant le nommage des variables Le nom de variable est très important car il véhicule l’intention du programmeur concernant le rôle de la variable. Il ne faut pas hésiter à prendre des noms de variables explicites et suffisamment longs (sans exagérer bien sûr. . . ).

Pour déterminer un nom de variable, la convention que nous suivrons est que les noms de variables sont formés de mots en minuscules en utilisant uniquement les lettres dea à z sans accent. Si plusieurs mots sont combinés pour créer le nom, ils doivent être séparés par le caractère souligné _. On peut éventuellement accoler des chiffres en fin du nom de variable (sans les séparer des lettres précédentes).

Voici quelques exemples de noms de variable valides : — compteur

— plus_grand_nombre — calcul1, calcul2

— min_liste1 , min_liste2

Les noms suivants ne respectent pas les conventions de nommage :

— Compteur : incorrect car il y a un C majuscule (seules les minuscules sont autorisées). — plusgrandnombre : incorrect car il n’y a pas de séparation avec des _ entre les éléments

du nom

— 1calcul : incorrect car il y a un chiffre au début du nom (alors que les chiffres ne doivent être qu’en fin)

— min_liste_1 : incorrect car le chiffre est séparé du reste par _ — élève : incorrect car les accents sont interdits

Remarques :

— les noms de fonctions suivent les mêmes règles

— les noms de variables contenant des données complexes comme des listes, des ensembles et des dictionnaires commencent par une majuscule afin de les distinguer des variables contenant des données plus simples. Il s’agit d’une convention spécifique à notre cours.