1.1 Console R

R est un langage interactif. La console de R est un peu comme une calculatrice.

1 + 1

## [1] 2

2*5 + 1

## [1] 11

Dans les blocs de code précédents, l’invite de commande (en anglais prompt) de la console R n’est pas affichée. Elle ne sera jamais affichée dans ces notes, pour alléger la présentation. Par défaut dans la console R, l’invite de commande est le symbole >. Lorsque la dernière ligne de la console R débute par ce symbole, R est prêt à recevoir une commande. Le symbole + indique quant à lui que la dernière commande soumise dans la console est incomplète, comme dans cet exemple.

> 1 + 3 -
+   2

## [1] 2

Ici, il manque un terme dans l’opération sur la première ligne puisque l’opérateur de soustraction - n’est pas suivi d’une valeur. Les commandes incomplètes sont souvent dues à des parenthèses ou des guillemets non fermés.

Dans ces notes, les blocs débutant par le symbole ## seront toujours des sorties produites par R.

1.2 Résultats en mémoire

Comment garder une copie en mémoire d’un résultat?

Il faut assigner le résultat à un nom, ce qui crée un objet en mémoire :

a <- 1 + 1

• <- est l’opérateur d’assignation;
• a est le nom (ou le symbole) référant à l’objet créé en mémoire;
• 1 + 1 est l’expression générant le résultat à enregistrer, dans laquelle 1 est une valeur et + un opérateur arithmétique;
• 2 est la valeur contenue dans l’objet créé.

Notons que = est aussi un opérateur d’assignation. Cet opérateur est utilisé en R pour assigner une valeur à un argument lors de l’appel d’une fonction. Cependant, pour l’assignation d’une valeur à un nom d’objet, la pratique la plus recommandée en programmation R est d’utiliser <- plutôt que =. La différence entre <- et = sera abordée plus tard, dans les notes sur les bonnes pratiques.

1.3 Accéder à un objet en mémoire

Comment accéder à un résultat gardé en mémoire dans un objet?

Il faut utiliser le nom référant à l’objet dans nos instructions R. Par exemple, pour afficher un objet, il suffit de taper son nom dans la console :

a

## [1] 2

mais pas :

"a"

## [1] "a"

car les guillemets servent à créer des chaînes de caractères.

De plus, il faut respecter la casse car R différencie les majuscules et les minuscules. Donc A n’est pas le même symbole que a en R.

a

## [1] 2

print(a)

## [1] 2

ls()

## [1] "a"

search()

## [1] ".GlobalEnv"        "package:stats"     "package:graphics"  "package:grDevices"
## [5] "package:utils"     "package:datasets"  "package:methods"   "Autoloads"        
## [9] "package:base"

ls(name = "package:stats")

##  [1] "acf"                  "acf2AR"               "add.scope"           
##  [4] "add1"                 "addmargins"           "aggregate"           
##  [7] "aggregate.data.frame" "aggregate.ts"         "AIC"                 
## [10] "alias"                "anova"                "ansari.test"         
## [13] "aov"                  "approx"               "approxfun"           
##  [ reached getOption("max.print") -- omitted 434 entries ]

casefold

## function (x, upper = FALSE) 
## if (upper) toupper(x) else tolower(x)
## <bytecode: 0x00000000164e31b8>
## <environment: namespace:base>

women

##    height weight
## 1      58    115
## 2      59    117
## 3      60    120
## 4      61    123
## 5      62    126
## 6      63    129
## 7      64    132
## 8      65    135
## 9      66    139
## 10     67    142
## 11     68    146
## 12     69    150
## 13     70    154
## 14     71    159
## 15     72    164

str(casefold)

## function (x, upper = FALSE)

str(women)

## 'data.frame':    15 obs. of  2 variables:
##  $ height: num  58 59 60 61 62 63 64 65 66 67 ...
##  $ weight: num  115 117 120 123 126 129 132 135 139 142 ...

2.1 Écriture d’un appel à une fonction

Comment écrire un appel de fonction R?

Un appel de fonction est une instruction formée des éléments suivants, en respectant cet ordre :

1. le nom de la fonction à appeler;
2. une parenthèse ouvrante (;
3. au besoin, des valeurs pour les arguments, spécifiées comme suit (et séparés par une virgule si plus d’une valeur d’argument est à donner en entrée) :
   1. nom de l’argument, suivi de l’opérateur = (éléments non obligatoires),
   2. expression générant la valeur à assigner à l’argument (souvent simplement le nom d’un objet);
4. une parenthèse fermante ).

Dans l’exemple précédent, c’est-à-dire :

casefold(x = c("Bonjour", "à", "tous!"), upper = TRUE)

deux valeurs sont fournies en entrée, en spécifiant les noms des arguments auxquels les assigner. Le résultat suivant est obtenu :

## [1] "BONJOUR" "À"       "TOUS!"

Ici, la valeur par défaut de l’argument upper est FALSE. Pour utiliser cette valeur, il n’est pas nécessaire de fournir de valeur à l’argument dans l’appel de fonction.

casefold(x = c("Bonjour", "à", "tous!"))

## [1] "bonjour" "à"       "tous!"

Cependant, l’argument x n’a pas de valeur par défaut et ne lui fournir aucune valeur génère une erreur.

casefold()

## Error in tolower(x): argument "x" is missing, with no default

Comment sont interprétées les valeurs passées en entrée sans être assignées à un argument?

Si une valeur est passée en entrée sans être explicitement assignée à un argument, elle est par défaut assignée au premier argument non spécifié, en respectant l’ordre des arguments dans la définition de la fonction. Voici quelques exemples et les résultats obtenus.

casefold(c("Bonjour", "à", "tous!"))

## [1] "bonjour" "à"       "tous!"

Ici, la valeur c("Bonjour", "à", "tous!") n’est pas assignée explicitement à un argument par l’utilisateur. R l’assigne donc implicitement au premier argument, soit x.

casefold(c("Bonjour", "à", "tous!"), TRUE)

## [1] "BONJOUR" "À"       "TOUS!"

Ici, les deux valeurs fournies en entrée ne sont pas assignées explicitement à des arguments par l’utilisateur. Elles sont donc assignées implicitement en respectant l’ordre des arguments : la première valeur fournie, soit "Bonjour", "à", "tous!" est assignée au premier argument, soit x; la deuxième valeur fournie, soit TRUE est assignée au deuxième argument, soit upper.

casefold(FALSE, c("Bonjour", "à", "tous!"))

## Warning in if (upper) toupper(x) else tolower(x): the condition has length > 1 and only
## the first element will be used

## Error in if (upper) toupper(x) else tolower(x): argument is not interpretable as logical

Ici, l’ordre dans lequel les valeurs sont fournies implique que FALSE est assigné à x et c("Bonjour", "à", "tous!") est assigné à upper. Cela génère un avertissement et une erreur, car les arguments reçoivent alors des valeurs qui ne sont pas des types attendus.

casefold(FALSE, x = c("Bonjour", "à", "tous!"))

## [1] "bonjour" "à"       "tous!"

Si la valeur c("Bonjour", "à", "tous!") est explicitement assignée à l’argument x, la valeur FALSE est implicitement assignée à upper, même si elle est fournie en première position, car les assignations explicites ont préséance sur les assignations implicites.

casefold(c("Bonjour", "à", "tous!"), upper = TRUE)

2.2 Fonctionnement vectoriel

Une particularité de R, qui le distingue de nombreux autres langages informatiques, est que plusieurs de ses fonctions agissent de façon vectorielle. Cela signifie qu’elles effectuent un traitement élément par élément sur le ou les objets reçus en entrée. Ainsi, l’appel précédent à la fonction casefold, génère l’application répétitive d’un traitement sur tous les éléments du vecteur de chaînes de caractères assigné à l’argument x. Dans plusieurs langages informatiques, il aurait fallu écrire une boucle pour arriver à répéter le traitement.

Lors de la réalisation de calculs, ce fonctionnement vectoriel de R est très pratique. Il est simple, par exemple, d’additionner deux vecteurs numériques élément par élément,

c(3, 6, 2, 6) + c(4, 2, 2, 1)

## [1] 7 8 4 7

ou encore de calculer la racine carrée tous les éléments d’un vecteur en une seule commande.

sqrt(c(3, 6, 2, 6))

## [1] 1.732051 2.449490 1.414214 2.449490

2.3 L’argument ... et ses deux utilités

Certaines fonctions R possèdent un argument nommé « ... ». C’est le cas par exemple de la fonction c utilisée précédemment, qui sert à combiner des valeurs dans un vecteur ou une liste.

args(c)

## function (...) 
## NULL

C’est aussi le cas de la fonction apply, servant à appliquer un calcul sur des sous-sections d’un objet.

args(apply)

## function (X, MARGIN, FUN, ...) 
## NULL

L’argument ... n’a pas la même utilisé dans ces deux fonctions. Je vais utiliser ces deux exemples de fonction pour illustrer les deux utilités potentielles de ....

Utilité 1 : recevoir en entrée un nombre indéterminé de valeurs à traiter

La première utilité de ... est de permettre à une fonction de recevoir en entrée un nombre indéterminé de valeurs à traiter. Si ... est placé au tout début de la liste des arguments, il a typiquement cette utilité. C’est le cas pour la fonction c. Cette fonction peut combiner autant de valeurs que désiré par l’utilisateur grâce à l’argument .... Voici des exemples.

c("a", "c")

## [1] "a" "c"

c(4.5, 6.8, 2.3, 5.1, 0.9)

## [1] 4.5 6.8 2.3 5.1 0.9

c("Zoé" = 4.5, "Luc" = 6.8, "Ian" = 2.3, "Mia" = 5.1, "Kim" = 0.9)

## Zoé Luc Ian Mia Kim 
## 4.5 6.8 2.3 5.1 0.9

args(apply)

## function (X, MARGIN, FUN, ...) 
## NULL

apply(X = women, MARGIN = 2, FUN = mean)

##   height   weight 
##  65.0000 136.7333

apply(X = women, MARGIN = 2, FUN = mean, trim = 0.3)

##   height   weight 
##  65.0000 135.5714

2.4 Comment utiliser une fonction d’ajustement de modèle ?

Étant donné que R est un langage conçu pour effectuer des calculs statistiques et créer des graphiques, il sert fréquemment à ajuster des modèles statistiques. R possède une classe d’objets particulière dédiée à la spécification de modèles : les formules. Comprendre comment utiliser une fonction d’ajustement de modèle en R revient principalement à comprendre comment correctement spécifier une formule R.

Par exemple, la fonction lm sert à ajuster un modèle linéaire. Le premier argument de cette fonction est une formule. Voici un exemple d’ajustement d’une régression linéaire simple sur les données women, en utilisant le poids comme variable réponse et la grandeur comme variable explicative.

reg <- lm(weight ~ height, data = women)

L’objet weight ~ height est une formule.

str(weight ~ height)

## Class 'formula'  language weight ~ height
##   ..- attr(*, ".Environment")=<environment: R_GlobalEnv>

La partie de gauche de la formule (à gauche du ~) contient le ou, plus rarement, les noms des variables réponse. La partie de droite contient pour sa part le ou les noms des variables explicatives. Ces noms sont accompagnés, au besoin, d’opérateurs et de fonctions pour désigner comment former les termes du modèle à partir des variables explicatives. Par exemple, voici la formule à utiliser dans l’appel à la fonction lm pour effectuer une régression polynomiale de degré deux avec les données women.

reg_poly <- lm(weight ~ height + I(height^2), data = women)

L’écriture de formule sera abordée dans les notes sur les calculs en R.

Comment accéder aux résultats d’une fonction d’ajustement de modèle?

Un objet obtenu en sortie d’une fonction d’ajustement de modèle contient beaucoup plus d’informations qu’il ne le laisse paraître à première vue.

Par exemple, affichons dans la console l’objet reg créé dans le premier exemple d’ajustement de modèle.

reg 

## 
## Call:
## lm(formula = weight ~ height, data = women)
## 
## Coefficients:
## (Intercept)       height  
##      -87.52         3.45

Seul un court extrait des résultats contenus dans reg est imprimé. Un résumé plus complet des résultats est obtenu avec la fonction summary.

summary(reg)

## 
## Call:
## lm(formula = weight ~ height, data = women)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -1.7333 -1.1333 -0.3833  0.7417  3.1167 
## 
## Coefficients:
##              Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -87.51667    5.93694  -14.74 1.71e-09 ***
## height        3.45000    0.09114   37.85 1.09e-14 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 1.525 on 13 degrees of freedom
## Multiple R-squared:  0.991,  Adjusted R-squared:  0.9903 
## F-statistic:  1433 on 1 and 13 DF,  p-value: 1.091e-14

Cependant, en réalité, l’objet reg contient plus d’éléments que ce que le laisse croire les sorties précédentes.

L’objet reg est une liste de sous-objets contenant les résultats de l’ajustement du modèle :

str(reg, max.level = 1, give.attr = FALSE)

## List of 12
##  $ coefficients : Named num [1:2] -87.52 3.45
##  $ residuals    : Named num [1:15] 2.4167 0.9667 0.5167 0.0667 -0.3833 ...
##  $ effects      : Named num [1:15] -529.566 57.73 -0.058 -0.486 -0.914 ...
##  $ rank         : int 2
##  $ fitted.values: Named num [1:15] 113 116 119 123 126 ...
##  $ assign       : int [1:2] 0 1
##  $ qr           :List of 5
##  $ df.residual  : int 13
##  $ xlevels      : Named list()
##  $ call         : language lm(formula = weight ~ height, data = women)
##  $ terms        :Classes 'terms', 'formula'  language weight ~ height
##  $ model        :'data.frame':   15 obs. of  2 variables:

Un élément de la liste reg peut être extrait avec l’opérateur $ comme suit :

reg$coefficients

## (Intercept)      height 
##   -87.51667     3.45000

Cependant, il existe des fonctions servant spécifiquement à extraire des éléments d’une sortie de modèle. Par exemple, la fonction coefficients extrait les coefficients du modèle :

coefficients(reg)

## (Intercept)      height 
##   -87.51667     3.45000

La fonction summary, en plus d’afficher un résumé des résultats tel que vu précédemment, retourne en sortie une liste contenant quelques résultats complémentaires à ceux retournés par la fonction d’ajustement du modèle :

regSummary <- summary(reg)
str(regSummary, max.level = 1, give.attr = FALSE)

## List of 11
##  $ call         : language lm(formula = weight ~ height, data = women)
##  $ terms        :Classes 'terms', 'formula'  language weight ~ height
##  $ residuals    : Named num [1:15] 2.4167 0.9667 0.5167 0.0667 -0.3833 ...
##  $ coefficients : num [1:2, 1:4] -87.5167 3.45 5.9369 0.0911 -14.741 ...
##  $ aliased      : Named logi [1:2] FALSE FALSE
##  $ sigma        : num 1.53
##  $ df           : int [1:3] 2 13 2
##  $ r.squared    : num 0.991
##  $ adj.r.squared: num 0.99
##  $ fstatistic   : Named num [1:3] 1433 1 13
##  $ cov.unscaled : num [1:2, 1:2] 15.15595 -0.23214 -0.23214 0.00357

7.1 Options de R

Comment connaître et modifier les options de R?

Une session R (tout comme un processus R) comporte un certain nombre de paramètres nommés options. La fonction options permet de connaître les valeurs prises par les options, ainsi que de les modifier. Il faut d’abord aller voir la fiche d’aide de la fonction (ouverte par la commande help(options)), pour obtenir de l’information sur ces options.

Par exemple, la façon dont les nombres sont affichés dans la console est notamment contrôlée par les options digits et scipen. Ces options prennent par défaut les valeurs suivantes.

# Afin de garder une copie des valeurs par défaut avant de les modifier
options_default <- options()

options_default$digits

## [1] 7

options_default$scipen

## [1] 0

Option digits : contrôle du nombre maximal de chiffres affichés

L’option digits représente le nombre maximal de chiffres affichés, par exemple :

1.23456789

## [1] 1.234568

Le nombre est arrondi pour respecter ce nombre maximal de chiffres. Cette option peut être modifiée comme suit.

options(digits = 4)
1.23456789

## [1] 1.235

Option scipen : contrôle de l’affichage en format scientifique

L’option scipen contrôle pour sa part l’affichage en format scientifique. R affiche les très grands nombres dans ce format. Par exemple, par défaut

100000

## [1] 1e+05

est affiché en format scientifique, mais pas

10000

## [1] 10000

En modifiant la valeur de scipen comme suit

options(scipen = -1)

10000 sera lui aussi affiché en format scientifique.

10000

## [1] 1e+04

Remarque : Si nous avons préalablement enregistré les valeurs par défaut des options (dans notre cas, nous les avons dans options_default), il est facile de redonner d’une coup leurs valeurs par défaut à toutes les options lorsque nous le souhaitons, par la commande suivante.

options(options_default)

Notons également que toute modification aux options est perdue à la fermeture de session. En effet, toute nouvelle session R démarre avec des options prenant leurs valeurs par défaut.

9.1 Règles de syntaxe

Quelles sont les règles de syntaxe du langage R?

Lors de l’écriture d’un programme R, il y a quelques règles de syntaxe à respecter. En plus des règles concernant les choix de noms d’objets énumérées précédemment, voici les règles syntaxiques de base du langage R [3].

• R respecte la casse des caractères (il fait toujours la distinction entre les majuscules et les minuscules, comme il a déjà été mentionné).
• Dans un nombre réel, la décimale est représentée par un point et non par une virgule.
• Chaque commande doit se terminer par un retour de chariot ou un point-virgule (moins usuel).
• Une commande peut s’étaler sur plusieurs lignes.
• Il est possible de mettre plusieurs commandes sur une même ligne, à condition de séparer les commandes par des points-virgules.
• Les différents éléments d’une commande peuvent ou non être séparés par un ou plusieurs espaces. C’est uniquement une question de style.
• Le symbole # sert à insérer des commentaires dans un programme R. Sur une ligne, tout ce qui se trouve après un # est ignoré par R lors de l’exécution d’un programme.

# Exemple de ligne en commentaire, donc non exécutée
1 + 1  # exemple de commentaire suivant une instruction

9.2 Éditeurs de code R

Quel outil utiliser pour éditer un programme R?

Un programme R s’édite dans une fenêtre séparée de la console. Le GUI de la version Windows de R possède un éditeur de code R minimaliste, qui s’ouvre par le menu « Fichier > Nouveau script ». Par convention, l’extension .R ou .r est donnée à un programme R. À partir de cet éditeur, le raccourci clavier Ctrl-R permet de soumettre dans la console des lignes de code de l’éditeur.

Il existe cependant des outils bien plus performants que cet éditeur pour programmer en R. Plusieurs éditeurs de code R ou environnements intégrés de développement R (en anglais IDE pour Integrated Development Environment) sont offerts, notamment :

• RStudio (http://www.rstudio.com/),
• des extensions R pour Visual Studio Code (par exemple https://marketplace.visualstudio.com/items?itemName=Ikuyadeu.r)
• Emacs avec ESS (http://ess.r-project.org/),
• Eclipse avec StatET (https://eclipse.org/statet),
• Tinn-R (http://sourceforge.net/projects/tinn-r/),
• etc.

10.1 Éditeur de code R

L’éditeur de code R de RStudio est pourvu de plusieurs fonctionnalités, notamment :

• coloration syntaxique;
• complètement automatique (en anglais autocompletion);
• fermeture automatique de parenthèses, crochets, accolades (potentiellement colorés selon leur niveau) et guillemets;
• création possible de sections (commentaires terminant par quatre tirets ou plus) et accès à un outline permettant de se déplacer facilement entre les sections;
• pliage de code;
• configurable (beaucoup d’options dans le menu « Tools > Global Options… > Code »).

La fiche sur l’installation de R mentionne quelques configurations de RStudio qui pourraient vous intéresser.

Détails concernant le complètement automatique (autocompletion) :

RStudio peut compléter nos commandes pour nous. En cours de saisie d’une commande dans la console ou dans un script R, RStudio ouvre une petite fenêtre contenant des suggestions de suite à notre commande. Si cette fenêtre ne s’ouvre pas d’elle-même, la touche « Tab » devrait permettre de l’ouvrir. RStudio propose des suggestions de suite pour :

• les noms d’objets se trouvant dans un des environnements dans le chemin de recherche,
• les noms des éléments d’une liste ou les noms de colonnes d’un data frame après l’opérateur $,
• les arguments à ajouter à un appel de fonction,
• etc.

Si vous n’aimez pas ce comportement, vous pouvez le configurer par le menu « Tools > Global Options… > Code > Completion ».

Détails concernant la fermeture automatique de parenthèses, guillemets et crochets :

RStudio offre aussi de fermer les parenthèses, guillemets et crochets automatiquement. Ainsi, si nous ouvrons une parenthèse dans un programme ou dans la console, une parenthèse fermante est automatiquement ajoutée à la ligne de commande.

Si vous n’aimez pas cette fonctionnalité, vous pouvez l’enlever par le menu « Tools > Global Options… > Code > Editing », en décochant l’option « Insert matching parens/quotes ».

10.2 Sous-fenêtres

La fenêtre principale de RStudio est divisée en sous-fenêtres, comprenant chacune potentiellement un choix de sous-fenêtres en onglets. La configuration par défaut propose les 4 sous-fenêtres suivantes :

• en haut à gauche : l’éditeur R (possibilité d’avoir plusieurs programmes ouverts, accessibles via des onglets);
• en bas à gauche : la console R (aussi une fenêtre Terminal et autres);
• en haut à droite : la visualisation du contenu des environnements chargés (aussi de l’historique des commandes et autres);
• en bas à droite : la visualisation de, notamment,
  • l’arborescence de fichiers (Files) sur votre ordinateur,
  • les graphiques produits (Plots),
  • les packages installés ,
  • les fiches d’aide (Help).

10.3 Fonctionnalités diverses

Plusieurs autres fonctionnalités de RStudio permettent de travailler de façon plus productive, par exemple les suivantes :

• Possibilité de lancer certaines commandes à partir de menus, notamment :
  • des appels aux fonctions courantes telles que :
    • help : en utilisant la barre de recherche de la sous-fenêtre Help,
    • install.packages : en utilisant le bouton Install de la sous-fenêtre Packages,
    • setwd: par le menu Session > Set Working Directory;
  • des commandes de construction de package par le menu Build;
• Nombreux raccourcis clavier (https://support.rstudio.com/hc/en-us/articles/200711853-Keyboard-Shortcuts), notamment :
  • les raccourcis usuels tels que :
    • Ctrl-C / Ctrl-V pour effectuer un copier / coller,
    • Ctrl-Z pour annuler la dernière action,
    • Ctrl-S pour enregistrer le document courant,
    • etc.;
  • Ctrl-Enter pour soumettre (dans la console) la ligne du programme source où le curseur se situe ou la sélection (dans l’éditeur);
  • Tab ou Ctrl+Space pour tenter un complètement automatique.