2.2 Stocker des données dans des variables

Dans le chapitre précédent nous avons vue comment manipuler les nombres en R et réaliser des calculs. Mais une fois un résultat obtenu, il disparait et n'est pas retenu en mémoire, ce qui n'est pas trés pratique. Comment faire pour dire au programme de retenir les résultats obtenus et les garder en mémoire ? Il nous faut pour cela utiliser des variables, qui permettent de stocker des données pour s'en souvenir.

Déclarer ma première variable

Pour crée une variable, il nous suffit d'écrire le nom de notre variable, le signe = puis les données dont on veut que notre variable se souvienne.

nomDeMaVariable = valeur

Bien entendu, valeur doit être remplacé par un nombre ou d'autres données manipulées par R.

Comme nous n'avons vu que les nombres pour l'instant, nous pouvons uniquement demander à nos variables de contenir des nombres. Nous verrons plus tard d'autres types de données. Déclarons notre première vraie variable :

age = 25 #On déclare une variable age qui vaut 25

Cette ligne de code déclare une variable age qui contient le nombre 25.

On dit que l'on assigne le nombre 25 à la variable age. Vous rencontrerez souvent ce terme d'assignation d'une valeur à une variable. Cela signifie simplement que l'on indique à la variable de retenir une valeur.

Vous pouvez déclarer autant de variables que vous voulez, à condition de leur donner des noms différents :

#Déclaration de plusieurs variables :
a = 12L
b = 8.02
c = 3 + 2i

Vous pouvez affecter à une variable n'importe quel type de donnée. Ici les variables a , b et c contiennent respectivement un integer , un double et un complex .

Afficher le contenu d'une variable

Maintenant que nous savons créer des variables, comment récupérer la valeur qu'elle contiennent ? Pour afficher ce que contient une variable, il suffit simplement d'écrire le nom de cette variable (dans la console ou dans notre programme), comme ceci :

age = 25 #on créer une variable age
age #on affiche la variable

La console va alors afficher le contenu de la variable en question. Il est aussi possible d'obtenir le même résultat en utilisant la fonction print() et indiquant entre les parenthèses le nom de la variable qu'on souhaite afficher dans la console. Les deux façons de faire donnent exactement le même résultat :

Remarque : Si vous essayez d'appeler une variable qui n'existe pas, alors R Studio vous dira qu'il ne connait pas cette variable et qu'il arrive pas à trouver l'objet correspondant :

Modifier le contenu d'une variable

Maintenant que nous savons comment créer une variable et comment l'afficher, regardons comment en modifier la valeur. Pour cela, il suffit simplement de re-définir la variable, comme si on la créeait à nouveau, en lui affectant une nouvelle valeur :

age = 25
print(age) #affiche 25
#le temps passe vite : on modifie le contenu de notre variable age
age = 26
#on affiche le contenu de age :
print(age) #vaut 26 maintenant

Plutôt facile non ? Remarquez que vous pouvez affecter n'importe quoi d'autre à une variable, si celle ci contenais un nombre entier vous pouvez lui affecter un complexe à la place ou n'importe quel autre objet de R.

age = 25 
age = 25 + 4i #qui ne rêve pas d'avoir un age imaginaire ?

Vous pouvez aussi affecter le contenu d'une variable dans une autre variable. Cela revient à copier ce que contient la première variable dans la seconde variable.

ageCapitaine = 40
ageMousailon = ageCapitaine
print(ageCapitaine) #affiche 40
print(ageMousailon) #affiche 40 aussi

Remarquez que chaque variable est indépendante. Si on modifie la première variable, la seconde variable n'est pas affectée :

ageCapitaine = 40
ageMousailon = ageCapitaine
ageCapitaine = 45 #le capitaine prend un coup de vieux !
print(ageCapitaine) #affiche 45 cette fois
print(ageMousailon) #affiche 40 aussi

On peut ainsi voir les variables comme des boites indépendantes qui contiennent des valeurs et que l'on repère grace à leur nom.

L'ancien opérateur <=

Il existe une ancienne syntaxe pour déclarer des variables en R, qui utilise le signe <= (un cheveron suivit d'un signe =) au lieu du signe = que nous vennons de voir.

argent <= 1000 #autre façon de déclarer une variable

Elle est (presque) identique à la syntaxe avec le signe = , à quelques différence prêts que nous exliquerons dans le chapitre "old R". Bien que moins pratique à écrire, cette ancienne syntaxe reste utilisée par une majorité de personnes, et se rencontre encore dans de nombreux tutoriels. Nous utiliserons tous au long de cet ouvrage la nouvelle syntaxe avec le signe = , plus simple à écrire et à lire.

Bien nommer ces variables

Pour déclarer une variable, nous avons vu qu'il suffit d'écrire le nom de la variable, suivit d'un signe = et de la valeur que l'on veut notre variable contienne. Nous pouvons donner quasiment n'importe quel nom à notre variable, mais il y a quelques régles à respecter :

• Un nom de variable ne doit jamais commencer par un nombre. Exemple : 21Guns
• Un nom de variable ne doit pas contenir d'espace ou de caractére spécial comme des accents : une variable, prénom, Smith&Watson
• Certains nom sont des noms clefs réservés par le langage R, nous ne pouvons pas les utiliser. Par exemple le nom class que nous avons vu plus haut est déjà pris, on ne donc pas appeler une variable class. Nous n'allons pas vous donner la liste de tous les mots cléfs réservés car cela ne servira à rien, vous n'allez pas l'apprendre par coeur. Gardez juste en tête que parfois si votre code semble ne pas fonctionner correctement, il se peut que vous ayez nommé une variable avec un mot clef non autorisé.

En dehors de ces régles, vous pouvez utiliser tous les lettres, des chiffres, et des majuscules pour nomer vos variables. Voici quelques exemples de mauvais et bons noms de variables :

#Mauvais noms de variables
1erPrix = 100 #Ce nom de variable n'est pas valide !
Dupont&Dupont = 2 #Pas valable car contient un caractére spécial 
class = 12 #Pas valable, le mot class est réservé par le langage et existe déjà !
taux de TVA = 0.20 #Impossible d'utiliser des espaces

#Bons noms de variables
TauxTVA = 0.20 #Valable 
pi = 3.14 #Valable
je_suis_une_variable = 1 #Valable 
prixDuRepas = 12 #Valable

Les bonnes pratiques

Il existe également de bonnes pratiques, qui ne sont pas obligatoires, mais qu'il est recommandé de suivre pour que votre code soit plus facile à lire :

• Donnez des noms de variables explictes : par exemple ageest plus parlant que simplement la lettre a . N'hésitez pas à utiliser le "tiret du bas" (touche 8) _ pour écrire des noms composé et explictes comme age_capitaine. Cette façon de faire avec le "tiret du bas" est recommandée par la plupart des programmeurs comme une norme "officielle".
• Evitez les noms qui donnent pas d'information et qui sont trop vague, comme par exemple data ou taux .
• Eviter les abréviations. Ainsi age_capitaine est plus parlant que simplement ac. L'idéral est qu'on puisse comprendre à quoi sert une variable uniquement en lisant son nom !

Voici quelques exemples de variables avec des noms peu claires puis les mêmes variables avec des noms plus compréhensibles :

#Ces variables ont des noms valides mais peu lisibles :
ac = 45
p = 100
v = 12
canons = 8
ageCapitaine = 45 #Acceptable, mais ne suis pas la norme "officielle"

#Ces variables ont des noms qui rendent facile de comprendre à quoi elles servent :
age_capitaine = 45
prix_epee = 100
vitesse_bateau_noeud = 12 
nb_canons = 8

Les variables et l'environnement

Quand vous avez crée des variables, celles-ci sont retenues en mémoire par R-studio. L'endroit où vivent les variables s'appellent l'environnement. C'est là où sont stockés les différentes boites des variables. Si l'environnement "naturel" est le lieu où vivent les animaux et les plantes, l'environnement en programmation est de la même façon le lieu de vie des variables et autres objets. Une variable appartient toujours à un environnement, comme un animal ne peut exister en dehors de son habitat naturel.

Chaque programme contient toujours au moins un environnement principal, que l'on appelle l'environnement global. Quand on créer nos variables, elles sont ajoutée à cet environnement global. Vous pouvez voir les variables et autres objets que contient votre environnement grace à l'onglet _environnement _qui se trouve en haut à droite dans R Studio :

Ici comme vous pouvez le voir, notre environnement est vide car nous n'avons encore crée aucune variable. Si on décide de créer des variables, vous pouvez voir que notre environnement va se remplir, et afficher les variables que nous venons de créer :

age = 25
taille = 1.83

Regardons maintenant ce que contient notre environnement :
On peut voir qu'il contient nos deux variables, et que R Studio nous affiche le nom et la valeur de chaque variable.

Remarquez le menu déroulant avec inscrit "Global Environment". Cela signifie que nous sommes bien dans l'environment global, qui est rappelons le l'environement par défaut où vivent les variables. Comme vous pouvez vous en douter, il sera possible plus tard de créer différents environnements, pour que nos variables ne vivent pas toutes ensembles au même endroit.

Afficher plus d'informations sur nos variables :

Vous pouvez modifier la façon dont l'onglet environnement affiche les variables de l'environnement en cliquant le le menu déroulant "list" en haut à gauche. Passez l'affiche en mode "gird", qui est plus pratique. Regardez à quoi ressemble ce nouvel affichage :
On peut remarquer que cet affichage nous donne plus d'informations sur nos variables. Il nous indique par exemple le type de nos variables (ici numeric pour des nombres), la longueur (nous parlerons des type et de la longueur plus tard), la taille utilisée en mémoire et enfin la valeur stockée (le contenu de la boite).

Vous pouvez aussi utiliser la petite case devant chaque variable pour la selectionner, et ensuite appuyer sur le l'icone en forme de balai pour supprimer toutes les variables selectionnées de l'environnement. Attention, si vous validez la supression d'une variable, elle sera effacée et vous ne pourrez plus y accéder, l'information qu'elle contenait sera perdue.
Cette procédure est nénanmoins pratique quand vous avez trop de variables dans votre environnement et que vous voulez vous en débarasser.

La fenêtre d'environnement vous permet de vérifier en un clin d'oeil la valeur contenue par chaque variable, ainsi que de voir toutes les variables que vous avez créer. C'est donc plutôt utile, et vous vous en servirez souvent.

Retour sur les types de variables et numeric :

Si vous avez bien retenu la leçon précédente, nous avons vu que les seuls types de nombres en R étaient les integer , les double et le type complex . Pourquoi alors R studio nous affiche-il numeric dans la colonne type ? Existerait-il y autre type ? En réalité R studio n'affiche pas ici le type des objets ici comme l'interface le laisse croire, mais une autre propriété qui est la classe des objets. Nous reviendrons cette notion de class dans la partie sur les structures de données avancées. En attendant, retenez simplement que le "type" affiché dans l'environnement ne correspont pas au type réel des données.

Les expressions

On appelle expression une partie de code qui prendra une valeur quand elle sera exécutée par le programme. On dit alors que l'expression est évaluée, c'est à dire que le programme va la remplacer par sa valeur. Chaque fois que nous réalisons un calcul mathématique, nous évaluons en réalité une expression. Regardez l'expression suivante :

(2^3+5)*(2-1)

Lorsque cette ligne de code est exécutée, R va l'évaluer et la remplacer par sa valeur, qui est 13.

Il est possible d'affecter le résultat d'une expression directement à une variable, ce qui est trés pratique :

#On affecte le résultat d'une expression à une variable
age = 5*5+1 
print(age) #affiche 26

La "boite" age contiendra alors non pas l'expression 5*5+1 mais bien le résultat de cette expression, soit 26. L'ordinateur va en fait évaluer l'expression à droite du signe =, puis affecter la valeur prise par cette expression à la variable age.

Remarque : Ainsi quand on demande à la console d'afficher une variable en écrivant le nom de la variable, en réalité on lui demander d'évaluer l'expression en question. Ce qui se traduit par remplacer la variable par la valeur qu'elle contient.

age = 5*5+1 #On affecte le résultat d'une expression à la variable age 
age #on demande à R d'évaluer la variable age, et de la remplacer par sa valeur, soit 26
print(age) #on évalue age, puis on passe le nombre à la fonction print qui va alors l'afficher

Remarquez que l'évaluation des variables fonctionne partout : chaque fois que R éxécute notre programme et trouve une variable dedans, il va alors la remplacer par sa véritable valeur et continuer.

Une variable peut ainsi elle peut elle-même faire partie d'une expression. Lors que cette expression sera évaluée, la variable en question sera alors remplacée par la valeur qu'elle contient pour donner le résultat final de l'expression. Regardez l'exemple suivant pour bien comprendre :

taux_TVA = 0.20
prix = 100
#On affecte le résultat de l'expression prix*taux_TVA à une variable
tva_montant = prix*taux_TVA 
#on affiche le résultat
print(tva_montant) #affiche 20

La variable tva_montant se voit affecter le résultat de l'expression prix*taux_TVA qui est évaluée en voyant chaque variable remplacée par sa valeur. La variable prixest remplacée par sa valeur qui est 100alors que taux_TVAest remplacée par 0.20. Le résultat de l'expression finale est 20 et cette valeur est affectée à la variable tva_montant. Enfin on évalue cette variable en l'affichant dans la console.

Pourvoir utiliser des variables dans des expressions est très utile en programation, comme ce petit exemple en témoigne. On peut ainsi imaginer un programme qui prend le prix d'un produit, le taux de TVA, et calcul combien de TVA est payé sur ce produit. Si le taux de TVA vient à changé il suffit alors de changer la valeur de la variable associée et de relancer le programme pour avoir le résultat avec le nouveau taux imédiatement !

Expressions et instructions

Un programme se compose de deux types de choses : des expressions que nous vennons de voir, et d'instructions. Alors qu'une expression est un bout de code qui est remplacé par une valeur à l'exécution, une instruction est une ligne de code qui "fait" quelque chose, qui agit sur le monde. Une expression produisant simplement une valeur, cette valeur disparait si rien n'est fait avec, le programme l'oublie automatiquement imédiatement. A l'inverse une expression produit un changement.

Quand on affecte un nombre à une variable, le programme fait quelque chose, c'est une instruction. Le "monde" (l'environnement qui contient les variables) est modifié par cette ligne de code, car une nouvelle variable est ajoutée à l'environnement.

age = 20 + 5 #cette ligne de code est une instruction 
age + 1 #cette ligne est une expression (et aussi une instruction car elle affiche quelque chose)

De façon générale, toute ligne de code qui modifie l'état du programme (créer des variables, les modifier, les supprimer, affiche quelque chose, etc) est une instruction. A l'inverse une expression ne modifie pas le programme en soit, mais produit juste une valeur à partir de ses différents composants.

Voici une autre instruction que nous avons rencontré :

typeof(5+2i)

Cette ligne de code fait quelque chose, puisqu'elle affiche le type de l'objet qu'on manipule dans la console. Elle a donc un effet sur le monde, car si elle ne modifie pas l'environnement, elle affiche quelque chose dans la console.

Une instruction peut contenir en son sein une expression, comme par exemple :

taille = 1 + 0.80

Cette instruction affecte l'expression 1 + 0.80 à la variable taille. En soit l'expression 1 + 0.80 ne produit aucun effet sur le programme, elle produit une simple valeur que l'instruction va affecter à la variable taille. C'est toute la ligne qui produit un effet en créant une nouvelle variable dans l'environnement et est donc une instruction.

Une expression est également une instruction

Une expression seule est à la fois une expression (car elle produit une valeur) et une instruction (car elle modifie l'état du monde en affichant le résultat de l'expression dans la console). Par exemple :

5 + (2*2) #cette ligne est à la fois une instruction et une expression

Cette ligne de code va être remplacée par sa valeur à l'exécution du programme, c'est donc une expression. Mais cette valeur va automatiquement être affichée dans la console, et donc va affecter l'état du monde actuel. Donc c'est aussi une instruction.

A l'inverse, une instruction peut avoir le même effet sans pour autant être une expression, car elle ne produit pas de valeur. L'instruction suivante n'est pas une expression, car elle n'est pas remplacée par une valeur à l'exécution, elle affiche simplement un résultat dans la console :

print(5 + (2*2)) #cette instruction modifie le monde mais ne produit pas de valeur à l'exécution

A retenir

• On peut stocker l'information dans des variables en écrivant nomDeMaVariable = valeur . Il existe un autre opérateur pour créer des variables, <- , qui à le même effet, mais que nous n'utiliserons pas dans ce cours.
• On peut accéder à l'information stocké dans une variable simplement en écrivant le nom de la variable. Pour modifier le contenu d'une variable, il suffit de la déclarer à nouveau avec une autre valeur.
• Il existe certaines régles obligatoires à respecter pour choisir son nom de variables, comme ne pas commencer par un nombre. A part cela vous pouvez appelez votre variable comme vous voulez.
• Il existe aussi certaines bonnes pratiques pour choisir vos noms de variables, comme choisir des noms explicites et compréhensibles.
• Les variables sont créees dans l'environnement global, que l'on peut observer avec l'onglet environment . On peut alors voir le type des variables (la classe en réalité), leur valeur et leur poids en mémoire.
• Une expression est une ligne de code qui produit une valeur quand elle est exécuté. On peut affecter le résultat d'une expression à une variable. Une expression peut également contenir une variable à l'intérieur, qui sera alors remplacée par sa valeur au moment de l'évaluation de l'expression.
• Une instruction est une ligne de code qui modifie l'état du monde, comme créer une variable ou affiche du texte dans la console. Une instruction seule est donc à la fois une instruction car elle produit une valeur et aussi une instruction car cette valeur sera affichée dans la console.