Je vous recommande de lire les sections 1 à 5 de ce document avant la séance afin de se concentrer sur l’apprentissage (sections 6 à 9). Les sections 10 à 15 sont en quelque sorte des annexes, que je vous conseille de lire après le didacticiel.
En 2-3h, il est impossible de maitriser R. Par contre, il y a certains aspects de la logique de R qui sont essentiels à comprendre et à acquérir pour pouvoir apprendre par soi-même. Je vais donc essayer de vous fournir ces bases. Ce n’est pas la partie la plus intéressante, mais c’est la plus délicate à apprendre. Si vous maitrisez cette partie, alors vous serez indépendant sous R. Ces aspects concernent principalement les types (section 7) et structures des objets (section 8), ainsi que la manipulation de ces objets (section 9).
Ce didacticiel concerne uniquement l’utilisation de R, sa logique et sa syntaxe. Les applications (graphiques, statistiques…) ne sont pas abordées pour plusieurs raisons. Tout d’abord, chacun utilise R pour différentes raisons et applications. En plus, les applications sont quasiment infinies ; il est donc impossible de tout traiter. Ensuite, en commençant par les applications sans connaitre le fonctionnement, vous arriverez sûrement à utiliser R en reproduisant des bouts de codes trouvés un peu partout, mais sans forcément les comprendre et donc sans pouvoir les adapter à vos besoins. Vous finirez sûrement par comprendre comment R fonctionne, mais l’apprentissage sera beaucoup plus long (je dis ça par expérience). Enfin, si le fonctionnement est compris, vous aurez les bases pour apprendre les différentes applications.
Je vais vous embêter avec des questions de terminologie et je vais essayer de vous inculquer des habitudes de codage. Il est important de prendre l’habitude d’utiliser les bons termes (pour pouvoir échanger avec des collègues) et de bien organiser votre code (pour qu’il soit plus lisible).
R est un logiciel libre permettant de manipuler et analyser des données et de réaliser des graphiques. Il n’y a quasiment pas de menus, tout se fait par des lignes de commande (voir aussi Rcmdr et easieR). Ça rend les choses difficiles, surtout au début, mais c’est aussi grâce à cela que tout est possible ; on n’est pas limité par ce qui est proposé dans les menus.
R est développé par une communauté d’utilisateurs, qui peuvent contribuer sous la forme de packages. Il existe des milliers de packages qui contiennent des fonctions permettant d’effectuer des opérations particulières.
Avant de continuer, voici quelques petites précisions concernant ce document.
Ce document contient du texte et du code R. Le code est en grisé, et l’output dans des cadres blancs.
Dans les exercices ci-dessous, le code sera caché par défaut. Essayez avant d’afficher le code. Vous pourrez ensuite l’afficher (bouton hide/code à droite) pour vérifier si votre réponse est correcte. Des explications sont également données juste en dessous du code. Donc ne descendez pas trop vite dans le document.
Notez aussi que j’utilise le point comme symbole de décimale contrairement à la nomenclature française, mais c’est le symbole utilisé par R !
Si vous remarquez des erreurs, fautes de frappe, d’orthographe ou autres, merci de me les signaler !
Lorsque vous ouvrez R, vous trouvez une barre de menu et une fenêtre intitulée R Console. C’est dans cette fenêtre qu’il faut écrire les commandes. Le symbole > suivi du curseur clignotant indique que R est prêt !
Certaines opérations sont longues ; tant que le > et le curseur ne sont pas affichés sur la dernière ligne de la console, R est en train de travailler. Dans ce cas là, il faut attendre ! En cas de problèmes, le bouton STOP peut arrêter les opérations en cours.
Les commandes (input), les résultats (output), les messages (warnings) et erreurs (errors) s’affichent tous dans la console, dans différentes couleurs. Prenez l’habitude de lire ces messages ; même s’ils vous semblent obscurs, c’est grâce à eux que vous pourrez identifier d’où viennent les problèmes. Les erreurs notamment sont souvent décourageantes, mais il est essentiel de les comprendre. Si vous ne comprenez pas ce que ces messages signifient, un copier/coller dans un moteur de recherche devrait vous aider.
Il est possible de naviguer dans les commandes précédemment entrées en appuyant sur les flèches haut/bas sur le clavier.
En allant dans la barre de menu, vous pouver créer un document, soit avec l’icône soit dans Fichier > Nouveau document/script. Une nouvelle fenêtre s’ouvre : l’éditeur. C’est dans l’éditeur que vous allez créer des scripts, c’est-à-dire des fichiers qui contiennent une liste de commandes qui pourront être exécutées sur plusieurs jeux de données. Il est possible de sauvegarder ces scripts comme n’importe quel fichier (CTRL+s sous Windows ou cmd+s sous MacOS). Je vous conseille donc, même en phase d’apprentissage, d’écrire toutes vos commandes dans l’éditeur et de sauvegarder le fichier, plutôt que d’enregistrer l’espace de travail (cf. 5.3).
Dans l’éditeur, il suffit de sélectionner les commandes à exécuter et d’appuyer sur CTRL+r (Windows) ou cmd+ENTER (MacOS) pour envoyer vers la console automatiquement. C’est plus simple et plus sûr que le copier/coller.
Le symbole # permet d’insérer des commentaires dans du code R. N’hésitez pas à commenter vos scripts !
L’éditeur sous MacOS est vraiment bien. Pour les utilisateurs Windows et Linux, je vous conseille d’utiliser RStudio (cf. 3.4 et 5.4).
Quand vous quittez R, une fenêtre s’ouvre vous demandant si vous voulez sauver l’image de l’espace de travail. Il est conseillé de ne pas sauvegarder l’espace de travail afin d’éviter que les objets (et leurs erreurs) restent en mémoire lors de l’ouverture d’une nouvelle session.
Les choses sont un peu différentes dans RStudio (cf. 3.4), mais les mêmes fenêtres sont présentes : la console et l’éditeur, plus deux autres fenêtres (fichiers, packages, graphiques, aide, et historique). Il est possible de réorganiser ces fenêtres dans les préférences/options.
Pour les exemples ci-dessous ainsi que dans le reste du document, vous pouvez copier/coller le code dans la console (ou mieux, dans votre script puis l’envoyer à la console) pour essayer par vous-même de comprendre comment ça marche. N’hésitez pas à essayer ce qui vous passe par la tête ; le meilleur moyen pour apprendre est d’essayer et de faire des erreurs !
R travaille avec des objets : les données sont sauvegardées dans des objets, on manipule et travaille avec ces objets, et on exécute des opérations sur ces objets. Autrement dit, un objet est l’unité de base dans R, une variable qui peut contenir tout type et structure de données (cf. 7-8). Cela implique que les données doivent être stockées dans un objet pour pouvoir les manipuler : même si les données peuvent apparaitre dans la console, R ne pourra pas travailler dessus si elles ne sont pas stockées dans un objet.
Pour aider à la compréhension de la notion d’objet, voici une analogie : vous allez manger chez des amis qui vous proposent un plat merveilleux. Si vous rentrez chez vous ainsi, vous aurez uniquement savouré ce plat. En revanche, si vous leur demandez la recette, vous pourrez la réutiliser pour d’autres repas. Le fait d’avoir mangé le repas correspond dans R à exécuter une commande. Le fait de garder en mémoire la recette correspond au fait de garder l’objet en mémoire pour pouvoir l’utiliser ultérieurement.
Les objets n’existent que dans l’espace de travail tant qu’ils ne sont pas sauvegardés en tant que fichiers. Ce qui veut dire que :
La plupart du temps, vous créerez un objet directement à partir de l’output d’une fonction, d’un autre objet, ou de valeurs numériques ou caractères. Pour assigner des données à un objet, il faut utiliser le symbole :
<- (inférieur à, suivi d’un tiret sans espace entre les deux) ou= (mais que je ne conseille pas pour éviter les confusions, cf. 7.4 et 10.1)Je conseille de toujours laisser un espace avant et après ces symboles pour que le code soit propre.
Par exemple, pour assigner la valeur 1 à un objet nommé x (qui sera de mode numérique) :
x <- 1
Les valeurs ont été assignées à x, mais aucun ‘résultat’ n’apparait dans la console. On a en effet juste demandé à R de créer x, on ne lui a pas demandé d’afficher x. Pour afficher le contenu d’un objet, il suffit de taper son nom dans la console :
x
[1] 1Remarquez que si vous tapez 1 dans la console, R vous affichera directement la valeur 1 dans la console, montrant qu’aucun objet n’a été créé ; on a juste demandé à R d’afficher la valeur 1 :
1
[1] 1Il est aussi possible de stocker des informations plus complexes. Par exemple, il est possible de concaténer (combiner) des valeurs avec la fonction c(), en séparant les valeurs par des virgules :
y <- c(1.5, 3, 10.05)
y
[1] 1.50 3.00 10.05La fonction : créé une suite d’entiers entre deux limites. Pour stocker une suite d’entiers de 1 à 10 dans un objet nommé z :
z <- 1:10
z
[1] 1 2 3 4 5 6 7 8 9 10Pour assigner la moyenne (fonction mean()) d’une suite d’entiers de 1 à 10 à un objet appelé moyenne1 :
moyenne1 <- mean(1:10)
moyenne1
[1] 5.5Il est également possible d’utiliser des objets créés précédemment :
moyenne2 <- mean(x)
moyenne2
[1] 1Les deux moyennes sont identiques car x contient les valeurs 1 à 10. Dans le cas de moyenne2, on a appliqué la fonction mean() à un objet x. Le fait d’appliquer des opérations nouvelles à des objets stockés dans la mémoire est la manière dont R fonctionne.
Vous pouvez choisir le nom des objets comme vous le voulez. Mais faites en sorte que vous compreniez ce que cet objet contient !
Par ailleurs, il existe 3 règles importantes pour le nom des objets :
. et _ sont des symboles valides, le premier étant aussi permis au début du nom. Les autres caractères spéciaux/symboles ne sont pas permis dans le nomExemples de noms valides et différents : mes.donnees, mes_donnees, Mes.Donnees
Exemples de noms non valides : 2donnees, /donnees, $donnees
Une erreur fréquente dans R est : Error: object 'x' not found
Il y a 3 possibilités :
ls() dans la consoleLes objets peuvent être de différents modes et classes (cf. 8).
Le mode d’un objet correspond au type de données qu’il contient.
Les modes principaux de R sont : numérique (numeric), caractère (character), logique (logical) et fonction (function). Les noms entre parenthèses sont les noms utilisés par R ; les traductions françaises n’ont aucune valeur dans R !
Il est possible de vérifier le mode d’un objet avec la fonction mode() :
x <- 1:10
mode(x)
[1] "numeric"Les objets de mode numérique contiennent évidemment des nombres : entier (1 ; 20 ; 500 ; -3), réel (1.00 ; 20.25 ; 500.1 ; -3.55) ou complexe (3+2i).
Un caractère est une valeur contenant au moins une lettre : “abc”, “a1c”, “2bc”, " 2" (notez l’espace avant le 2). Dans R, les caractères apparaitront toujours entre guillemets. Les guillemets peuvent être simples (‘exemple’) ou doubles (“exemple”) ; il faut juste que le guillemet de fermeture soit le même que celui d’ouverture.
Le mode logique ne correspond qu’à deux valeurs possibles : TRUE et FALSE, en capitales sans guillemets. Lorsqu’elles sont converties en numériques, ces valeurs correspondent à 1 et 0 respectivement.
Si vous cherchez de la documentation, vous trouverez parfois les abréviations T et F. Cela suffit la plupart du temps, mais il est fortement conseillé de toujours utiliser les versions complètes TRUE et FALSE.
Une fonction applique une ou plusieurs opérations à des données et en sort un résultat. De nombreuses fonctions existent dans l’installation de base de R (par exemple mean()), et il en existe encore plus dans les packages. Vous pouvez aussi créer vos propres fonctions.
Un objet de mode fonction ne contient pas de résultat mais uniquement une suite d’opérations. Il est possible d’afficher cette suite d’opérations en tapant le nom de la fonction (une fonction est un objet) dans la console, par exemple mean :
function (x, ...)
UseMethod("mean")
<bytecode: 0x7f7fb219d2e0>
<environment: namespace:base>Mais en général, vous voulez appeler (call) cette fonction sur un objet de données (input), et assigner le résultat (output) à un autre objet. Dans ce cas là, il faudra utiliser des parenthèses après le nom de la fonction pour indiquer que l’on appelle la fonction et que l’on cherche à appliquer les opérations.
C’est ce que nous avons vu précédemment :
x <- c(3,4,6,8,12,15,20) on appelle la fonction c() pour concaténer des valeurs dans x
x
[1] 3 4 6 8 12 15 20mode(x) on appelle la fonction mode() pour afficher le mode de x
[1] "numeric"mean(x) on appelle la fonction mean() pour calculer la moyenne de x
[1] 9.714286Pour afficher l’aide d’une fonction, il suffit de taper son nom précédé d’un point d’interrogation, ou d’utiliser la fonction help(), dans la console (cf. 13) :
?mean
help(mean)
Les arguments sont les options de la fonction. Ils possèdent toujours des noms que l’on peut trouver dans la définition de la fonction sur la page d’aide. Les arguments sont tous listés entre les parenthèses de l’appel à la fonction, séparés par des virgules, et le symbole = permet d’assigner des valeurs (options) aux arguments.
Il n’est pas nécessaire d’écrire leur nom pour les modifier, l’ordre suffit.
Certains arguments possèdent des valeurs par défaut, que l’on peut identifier sur la page d’aide : le nom de l’argument est alors suivi du symbole = puis de la valeur par défaut. Ces valeurs par défaut sont celles qui seront utilisées si l’on n’assigne pas de valeur lors de l’appel à la fonction.
Si un argument n’a pas de valeur par défaut, il sera alors nécessaire d’attribuer une valeur lors de l’appel à la fonction, sinon il y aura une erreur du genre “l’argument x est manquant, avec aucune valeur par défaut”.
Dans l’appel à la fonction, il existe trois possibilités pour utiliser les arguments :
= ; les arguments non nommés utiliseront alors les valeurs par défautPrenons l’exemple de la fonction matrix() qui sert à créer des matrices et que nous utiliserons dans la section 8.2.
Sa page d’aide indique qu’elle comporte 5 arguments nommés data, nrow, ncol, byrow et dimnames, dans cet ordre.
Ils ont tous des valeurs par défaut car ils sont tous suivi de = et d’une valeur (respectivement : NA, 1, 1, FALSE et NULL).
L’argument data demande les données entrantes (input). Par défaut, des valeurs manquantes (NA ou ‘not available’, qui correspondent aux cases vides sous Excel) remplissent la matrice. Les arguments nrow et ncol indiquent le nombre de lignes et de colonnes respectivement, par défaut 1 ligne et 1 colonne. Laissons de côté les autres arguments.
Ces 3 lignes sont identiques et permettent de créer une matrice contenant les entiers de 1 à 10 répartis en 5 lignes et 2 colonnes :
matrix(data=1:10, nrow=5, ncol=2) : l’argument data contient les entiers de 1 à 10, les arguments nrow et ncol répartissent les données en 5 lignes et 2 colonnes respectivement ; on utilise les valeurs par défaut pour les arguments byrow et dimnames, on n’a donc pas besoin de les listermatrix(1:10, 5, 2) : même opération mais sans nommer les trois premiers arguments. L’ordre est alors essentiel (comparer matrix(1:10, 2, 5) par exemple)matrix(ncol=2, nrow=5, data=1:10) : en nommant les arguments, il est possible de les lister dans le désordremode() et comparez les outputs de chaque mode.mode, mean, c et matrix) en tant qu’objets.mat de 2 lignes et 3 colonnes contenant les 6 premières lettres de l’alphabet.mean() ? Quels sont leurs noms et valeurs par défaut ?Réponses :
# Objet de mode numérique
x <- 1:10
mode(x)
# Output sans guillemets
x
# Objet de mode caractère
y <- c("abc", "def")
mode(y)
# Output avec guillemets
y
# Objet de mode logique
z <- c(TRUE, TRUE, FALSE)
mode(z)
# Output sans guillemets
z
# Objets de mode fonction
mode(mean)
mode(mode)
mode(c)
mode(matrix)
# Matrice
let <- c("a","b","c","d","e","f")
mat <- matrix(data=let, nrow=2, ncol=3)
mat <- matrix(let, 2, 3)
mat <- matrix(nrow=2, data=let, ncol=3)
# mean()
# La fonction possède 3 arguments : x, trim et na.rm
# Les valeurs par défaut sont : 0 et FALSE pour trim et na.rm respectivement
# x n'a pas de valeur par défaut ; il est donc obligatoire de lui atrribuer une valeur dans l'appel à la fonctionLa classe d’un objet correspond à sa structure. Je vous présente ici les classes principales de R. Il est possible d’en créer d’autres, et certaines fonctions assignent d’ailleurs d’autres classes aux objets.
Un vecteur est l’unité de base dans R. C’est un objet sans dimension.
On peut voir ça comme un ensemble, une collection ou une suite de valeurs (nombres, caractères…).
Tous les éléments (valeurs) d’un vecteur sont du même mode. Si besoin, les éléments seront convertis en un mode commun. Par exemple, un vecteur contenant la séquence 1,2,3,a,5 sera de mode caractère, avec les chiffres convertis en caractères (parce que les caractères ne peuvent pas être convertis en nombres).
La fonction c() que nous avons utilisée précédemment (cf. 6.2) permet de concaténer des données en un vecteur (certaines valeurs seront converties si besoin pour avoir un mode commun).
Exemples :
x <- 1:10
mode(x)
[1] "numeric"class(x)
[1] "integer"y <- c("a","b","c")
mode(y)
[1] "character"class(y)
[1] "character"z <- c(1,2,3,"a",5)
z
[1] "1" "2" "3" "a" "5"mode(z)
[1] "character"class(z)
[1] "character"Les matrices sont des arrays à 2 dimensions. Elles se présentent sous la forme de tableaux.
Exemple (voir aussi 7.4.3) :
mat <- matrix(x, nrow=5, ncol=2)
mat
[,1] [,2]
[1,] 1 6
[2,] 2 7
[3,] 3 8
[4,] 4 9
[5,] 5 10mode(mat)
[1] "numeric"class(mat)
[1] "matrix"Un array est un vecteur avec des dimensions. Ça veut dire que tous les éléments d’un array doivent être de même mode. De plus, le nombre d’éléments doit être divisible par la longueur des dimensions : dans le cas d’une matrice (2D array), le nombre d’éléments doit être égal au nombre de colonnes multiplié par le nombre de lignes.
Exemple :
arr <- array(1:12, dim=c(2,3,2))
arr
, , 1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
, , 2
[,1] [,2] [,3]
[1,] 7 9 11
[2,] 8 10 12Nombre d’éléments = 1:12 = 12
Longueur des dimensions = 2x3x2 = 12
mode(arr)
[1] "numeric"class(arr)
[1] "array"C’est la particularité de R. Les listes sont les objets les plus flexibles : les éléments peuvent être de modes et longueurs différentes.
Une liste peut avoir une structure hiérarchique, ce qui veut dire que chaque élément d’une liste peut être un vecteur, un array ou une liste et ainsi de suite. La seule contrainte est que chaque élément de niveau le plus bas est un vecteur ; ses éléments sont donc tous du même mode.
Exemples :
my.list <- list(a=1:3, b=c("a","d"))
my.list
$a
[1] 1 2 3
$b
[1] "a" "d"mode(my.list)
[1] "list"class(my.list)
[1] "list"Une liste est de mode et classe ‘liste’ !
my.list2 <- list(a=list(num=1:3,let=c("a","b")), b=mat, d=c(4,5,"6d",7))
my.list2
$a
$a$num
[1] 1 2 3
$a$let
[1] "a" "b"
$b
[,1] [,2]
[1,] 1 6
[2,] 2 7
[3,] 3 8
[4,] 4 9
[5,] 5 10
$d
[1] "4" "5" "6d" "7" my.list2 est une liste composée de 3 éléments (a, b et d)
L’élément 1 de my.list2 s’appelle a et est une liste composée de 2 éléments (num et let)
L’élément 1 de a s’appelle num et est un vecteur de mode numérique composé de 3 éléments (1, 2 et 3)
L’élément 2 de a s’appelle let et est un vecteur de mode caractère composé de 2 éléments (a et b, qui n’ont rien à voir avec les éléments de my.list2)
L’élément 2 de my.list2 s’appelle b et est une matrice de mode numérique dont les valeurs sont issues de mat
L’élément 3 de my.list2 s’appelle d et est un vecteur de mode caractère composé de 4 éléments ("4", "5", "6d" et "7", tous convertis en caractère)
Lorsque les lignes de codes deviennent longues et complexes avec plusieurs fonctions imbriquées, utilisez les espaces de façon intelligente pour séparer les unités. Dans l’exemple de my.list2, je n’ai mis des espaces entre les arguments que pour séparer les éléments de my.list2. Les arguments permettant de définir la liste a ne sont pas espacés, ni ceux permettant de définir le vecteur d. Comme ça, on identifie plus facilement la structure de my.list2 dans le code.
Un data.frame est une liste avec un seul niveau hiérarchique, et dont tous les éléments sont de même longueur (même nombre de sous-éléments). Les éléments sont des vecteurs (donc les sous-éléments sont de même mode), mais les différents éléments peuvent être de mode différents.
Les data.frames sont souvent utilisés pour représenter des tableaux Excel : chaque colonne est un élément (vecteur) du data.frame et les colonnes peuvent être de modes différents. Il est normal que les colonnes aient le même nombre de lignes (et donc que les éléments aient la même longueur).
Bien que les matrices et les data.frames se ressemblent, ces objets sont très différents pour R. Une matrice est UN vecteur coupé en lignes et colonnes. Un data.frame est une liste de vecteurs, présentés en colonnes.
Les opérations sont en général plus rapides sur les matrices. Donc si vous avez des gros jeux de données, essayez d’utiliser des matrices plutôt que des data.frames.
Exemple :
my.df <- data.frame(num=1:3, let=c("a","b","c"))
my.df
num let
1 1 a
2 2 b
3 3 cLes lignes sont numérotées si elles ne sont pas nommées. Attention à ne pas confondre les numéros de lignes avec les valeurs de la première colonne (num).
mode(my.df)
[1] "list"Les data.frames sont également de mode liste, ce qui est normal.
class(my.df)
[1] "data.frame"Les facteurs ressemblent plus à un mode, mais pour R, c’est une classe.
Un facteur est un vecteur de caractère codé en numérique. Un facteur est en fait composé d’un vecteur d’entiers, où chaque entier est associé à un attribut (‘label’).
Dit autrement, les facteurs sont les variables catégorielles discrètes utilisées en statistique, par exemple sexe (valeurs = homme ou femme), couleur des yeux (valeurs = bleu, marron, vert…), etc. Chaque valeur (appelée ‘level’) est associée à un entier (de 1 au nombre de valeurs distinctes).
Certains logiciels ont besoin de créer des ‘dummy variables’ pour traiter ce genre de données. R traite ces variables discrètes facilement avec les facteurs, que ce soit pour les statistiques ou les graphiques. Cela accélère les opérations également.
Par defaut, lorsque vous créez un data.frame, les colonnes de caractères sont transformées en facteur.
Exemples :
my.fac <- factor(c("homme","femme","femme","homme"))
my.fac
[1] homme femme femme homme
Levels: femme hommemode(my.fac)
[1] "numeric"Remarquez que les valeurs sont de mode numérique (ce qui explique pourquoi elles ne sont pas entre guillemets).
class(my.fac)
[1] "factor"levels(my.fac)
[1] "femme" "homme"Les levels sont par défaut par ordre alphabétique.
as.numeric(my.fac)
[1] 2 1 1 2Lorsqu’on convertit un facteur en numérique, on voit la représentation numérique des facteurs.
R peut bien sûr gérer les dates. Les dates sont en fait une valeur numérique calculée en nombres de jours à partir d’une origine prédéfinie. Cette origine n’est pas la même sous R et sous Excel selon le système d’exploitation, ce qui pose parfois des problèmes.
Il existe de nombreuses fonctions et packages spécifiques pour manipuler les dates, mais nous n’entrerons pas dans le détail ici.
Exemples :
dat <- as.Date("27-07-2016", format="%d-%m-%Y")
dat
[1] "2016-07-27"mode(dat)
[1] "numeric"class(dat)
[1] "Date"C’est ici que vous allez commencer à travailler !
Cette section concerne la manipulation d’objets, et notamment comment en extraire une partie. C’est important car vous ne travaillerez pas forcément sur toutes les colonnes/lignes d’un tableau et il faudra savoir comment sélectionner celles qui vous intéressent.
Cette section est séparée par classe d’objet car chaque classe se comporte différemment. Il est donc essentiel de savoir reconnaitre la classe d’un objet. Le mode importe peu par contre.
Vous devriez avoir suffisamment d’exemples et d’exercices dans ce document pour apprendre à manipuler tous les objets. Il est possible que vous ayez besoin de plus de temps, alors n’hésitez pas à réessayer après ce didacticiel. Il est important que vous soyez à l’aise avec ces aspects avant d’aller plus loin.
Ces manipulations concernent les vecteurs de n’importe quel mode, mais également les vecteurs de dates et facteurs.
Créez deux vecteurs en utilisant la fonction : (pour l’aide, taper ?":"), (1) un vecteur x contenant des entiers de 1 à 50, et (2) y contenant des entiers de 50 à 1. Affichez-les dans la console. À votre avis, à quoi correspondent les nombres entre crochets ?
Réponse :
x <- 1:50
x
y <- 50:1
yLes nombres entre crochets indiquent la position dans le vecteur de l’élément affiché juste après. Dans le cas de x, [16] indique que l’élément affiché juste à droite (donc le nombre 16) est le 16è élément du vecteur x. C’est inutile dans ce cas, mais dans le cas de y, le 16è élément est le nombre 35, ce qui est moins évident. On parle d’indice. Ces indices sont au début de chaque ligne.
Selon la largeur de votre console, les lignes seront plus ou moins longues, et donc les indices ne s’afficheront pas aux mêmes positions.
En sachant cela, d’après vous, comment extrait-on un élément d’un vecteur, par exemple l’élément n°47 de x puis de y ?
Réponse :
x[47]
y[47]Le simple crochet permet d’extraire un ou plusieurs éléments d’un vecteur. Même si on ne dirait pas, le crochet est en fait une fonction (tapez ?"[" pour afficher l’aide).
Utilisation : tapez le nom de l’objet que vous souhaitez sélectionner suivi de crochets. Entre les crochets, indiquez un vecteur d’indices (ou de noms, voir plus bas).
Exercices :
x, str(x)names(x) <- paste("n", 1:50, sep=""). La fonction names() permet d’afficher ou modifier les noms des éléments des objets et la fonction paste() permet de coller des caractères.x, str(x)Réponses :
x[44:47]
y[44:47]
x[c(44,46,48)]
y[c(44,46,48)]
x[-45]
y[-45]
x[-c(1,45)]
y[-c(1,45)]
x[-(1:3)]
y[-(1:3)]
mean(x[1:45])
mean(y[1:45])
mean(x[-8])
mean(y[-8])
x
str(x)
names(x) <- paste("n", 1:50, sep="")
x
str(x)
x['n5']
x["n5"]
x[c("n5", "n6", "n7")] #Il n'est bien sûr pas possible d'utiliser la fonction ":" pour créer une suite de caractèresCréez une matrice mat contenant les entiers de 1 à 10 avec 5 lignes et 2 colonnes en utilisant la fonction matrix(), puis affichez-la dans la console.
Grâce à l’output, essayer de comprendre comment extraire les valeurs d’une matrice.
Réponse :
mat <- matrix(1:10, nrow=5, ncol=2)
matLe simple crochet permet d’extraire des lignes/colonnes d’une matrice.
Utilisation : tapez le nom de l’objet que vous souhaitez sélectionner suivi de crochets. Entre les crochets, commencez par mettre une virgule (sinon vous risquez de l’oublier ; si si, ça arrive, souvent même !). Avant la virgule, entrez un vecteur d’indices pour les lignes ; après la virgule, un vecteur d’indices pour les colonnes. Si vous voulez sélectionner toutes les lignes/colonnes, ne rien entrer dans la partie correspondante avant/après la virgule.
Exercices :
dimnames(mat) <- list(paste("row",1:5,sep=""), paste("col",1:2,sep="")). Les noms (dimnames()) sont modifiées par une liste contenant deux éléments : un vecteur de caractères pour les lignes et un autre pour les colonnes.z composé de deux valeurs : (1) la valeur de la 2è ligne et 1è colonne de mat, et (2) la valeur de la 3è ligne et 2è colonne de mat.mat2 à 2 lignes et 2 colonnes composée des valeurs (1) des deux premières lignes et de la 1è colonne de mat, et (2) des lignes 3 et 4 et de la colonne 2 de mat.Réponses :
mat[2,1]
mat[2,]
str(mat[2,]) #un vecteur d'entiers
mat[,1]
str(mat[,1]) #un vecteur d'entiers
mat[2:3,1]
str(mat[2:3,1]) #un vecteur d'entiers
mat[2:3,1:2]
mat[2:3,]
str(mat[2:3,]) #une matrice d'entiers (les 2 dimensions apparaissent dans les crochets après 'int')
mat[-2,1]
str(mat[-2,1]) #un vecteur d'entiers
mat[c(1,3), 1]
str(mat[c(1,3), 1]) #un vecteur d'entiers
dimnames(mat) <- list(paste("row",1:5,sep=""), paste("col",1:2,sep=""))
mat[c("row1","row3"),]
str(mat[c("row1","row3"),]) #une matrice d'entiers
z <- c(mat[2,1], mat[3,2])
z
mat2 <- matrix(c(mat[1:2,1], mat[3:4,2]), nrow=2, ncol=2)
mat2Si possible (1 seule colonne/ligne), les dimensions seront supprimées et l’output sera un vecteur.
Créez un array arr contenant les entiers de 1 à 20 avec 5 lignes, 2 colonnes et 2 niveaux dans la 3è dimension, en utilisant la fonction array(), puis affichez-la dans la console.
Réponse :
arr <- array(1:20, dim=c(5,2,2))
arrExtraire la 3è ligne, 1è colonne et 2è niveau de la 3è dim de arr.
Réponse :
arr[3,1,2]Le principe est le même qu’avec les matrices, mais avec plus de virgules pour séparer les indices pour chaque dimension.
Créez une liste mylist composée de 3 éléments : (1) une liste composée d’un vecteur d’entiers 1 à 3 et d’un vecteur de caractères a et b, (2) la matrice mat, et (3) un vecteur composé des valeurs 4, 5, 6d et 7. Utilisez la fonction list().
Affichez la liste et sa structure.
Grâce à l’output, essayer de comprendre comment extraire les valeurs d’une liste.
Réponse :
mylist <- list(list(1:3,c("a","b")), mat, c(4,5,"6d",7))
mylist
str(mylist) #Notez la structure hiérarchiqueLe simple crochet permet d’extraire une liste contenant les éléments d’une liste. Le double crochet permet d’extraire un élément d’une liste.
Utilisation : tapez le nom de l’objet que vous souhaitez sélectionner suivi de crochets. Entre les doubles crochets, entrez l’indice de l’élément que vous voulez extraire. Il n’est pas possible de sélectionner plusieurs éléments en même temps avec le double crochet. Pour sélectionner plusieurs éléments, il faut que l’output soit une liste ; il faut donc utiliser le simple crochet.
Exercices :
w comprenant 2 éléments : (1) la 2è ligne et la 1è colonne du 2è élément de mylist, et (2) le 2è élément du 1er élément du 1er élément de mylist.names(mylist) <- c("List1","MAT","VEC") et names(mylist[[1]]) <- c("L1vec1","L1vec2")MAT de mylist.vec1 de mylist.Réponses :
mylist[[1]]
mylist[1]
mylist[c(1,3)]
mylist[[1]][[1]]
mylist[[1]][[1]][1]
mylist[[2]][,1]
mylist[[2]][3,]
mylist[[3]][3]
w <- c(mylist[[2]][2,1], mylist[[1]][[1]][2])
names(mylist) <- c("L1","MAT","VEC")
names(mylist[[1]]) <- c("vec1","vec2")
mylist
mylist[["MAT"]]
mylist[["L1"]][["vec1"]]Les listes sont hiérarchiques et peuvent contenir toutes les classes d’objets. Pour savoir comment extraire un élément d’une liste, il faut donc savoir de quelle classe est cet élément. Et ainsi de suite dans la structure. La méthode utilisée dépendra de la classe comme on l’a vu précédemment.
Le symbole $ peut remplacer le double crochet dans une liste nommée. Il est alors possible d’utiliser les noms d’éléments sans guillemets. Ne pensez pas que cette méthode est mieux. Elle est peu utilisée pour créer des scripts/fonctions applicables à de nombreuses situations.
Exemples :
mylist$MAT
col1 col2
row1 1 6
row2 2 7
row3 3 8
row4 4 9
row5 5 10mylist$L1$vec1
[1] 1 2 3Créer un data.frame mydf contenant 3 colonnes et 10 lignes (dont les noms seront “r1”, “r2”, …, “r10”) avec la fonction data.frame() : (1) colonne A avec les entiers de 1 à 10, (2) colonne B contenant 10 valeurs aléatoires issues d’une distribution normale (utiliser la fonction rnorm()), et (3) colonne D contenant 5 “e” puis 5 “f” (la fonction rep(..., each=5) peut être utile). Affichez-le, ainsi que sa structure.
Réponse :
mydf <- data.frame(A=1:10, B=rnorm(10), D=rep(c("e","f"),each=5), row.names=paste("r",1:10,sep=""))
mydf
str(mydf)Pour extaire des valeurs à partir d’un data.frame, la notation liste est bien sûr applicable puisque les data.frames sont des listes particulières. Mais il est également possible d’utiliser la notation matrice, plus flexible et plus intuitive.
Exercices :
Réponses :
mydf[[2]] #notation liste
mydf[,2] #notation matrice
mydf[["B"]] #notation liste nommée
mydf[,"B"] #notation matrice nommée
mydf$B #notation $
mydf[[2]][2:3] #notation liste
mydf[2:3,2] #notation matrice
mydf[c("r2","r3"), "B"] #notation matrice nomméeIl est souvent intéressant d’extraire des lignes d’un data.frame en se basant sur les valeurs d’une colonne.
Par exemple, extraire les lignes qui contiennent “e” dans la colonne “D”.
La logique n’est pas intuitive, mais ce n’est pas très compliqué. En décomposant, cela donne : (1) dans mydf, (2) sélectionner (3) les lignes dont (4) les valeurs sont égales à (5) “e” dans (6) la colonne “D” de “mydf”.
Donc :
(1) mydf
(2) mydf[,]
(3) mydf[lignes,]
(4) mydf[lignes==valeur,] L’égalité est testé par le symbole ==, pour différencier du simple = des arguments
(5) mydf[lignes=="e",]
(6) mydf[mydf$D=="e",] Il est bien sûr possible de remplacer mydf$D par d’autres notations (mydf[[3]], mydf[['D']]).
A B D
r1 1 -1.5795649 e
r2 2 0.2555095 e
r3 3 0.6227635 e
r4 4 0.5079373 e
r5 5 -0.4499038 ePour extraire les lignes dont les valeurs de la colonne “D” ne contiennent pas “e”, utiliser le symbole différent != :
mydf[mydf$D!="e",]
A B D
r6 6 -0.1049976 f
r7 7 -0.7879905 f
r8 8 -1.7092761 f
r9 9 -0.6359420 f
r10 10 0.9078611 fPour extraire plusieurs valeurs, il faut alors utiliser le symbole %in% plutôt que ==. Exemples :
mydf[mydf$A %in% c(1,3,5), ]
A B D
r1 1 -1.5795649 e
r3 3 0.6227635 e
r5 5 -0.4499038 emydf[row.names(mydf) %in% c("r1","r10"), ]
A B D
r1 1 -1.5795649 e
r10 10 0.9078611 fPour extraire en fonction des valeurs de plusieurs colonnes, il faut utiliser les opérateur bouléen ET (&, toutes les conditions sont respectées) et OU (|, au moins une condition est respectée) :
mydf[mydf$D=="e" & mydf$A %in% c(1,3,5), ]
A B D
r1 1 -1.5795649 e
r3 3 0.6227635 e
r5 5 -0.4499038 emydf[mydf$D=="e" | mydf$A %in% c(8,10), ]
A B D
r1 1 -1.5795649 e
r2 2 0.2555095 e
r3 3 0.6227635 e
r4 4 0.5079373 e
r5 5 -0.4499038 e
r8 8 -1.7092761 f
r10 10 0.9078611 fCes manipulations fonctionnent bien sûr de la même façon sur les colonnes (après la virgule entre les simples crochets).
Pour ajouter une colonne à mydf, il suffit d’assigner un vecteur à une colonne supplémentaire :
mydf[[4]] <- rnorm(10)
A B D V4
r1 1 -1.5795649 e 0.341965486
r2 2 0.2555095 e 0.201031513
r3 3 0.6227635 e 0.556581860
r4 4 0.5079373 e -0.631212107
r5 5 -0.4499038 e 0.242101746
r6 6 -0.1049976 f -2.391774075
r7 7 -0.7879905 f -0.378202382
r8 8 -1.7092761 f 1.035118856
r9 9 -0.6359420 f 0.249394439
r10 10 0.9078611 f 0.006269643Il est aussi possible de créer directement une colonne nommée :
mydf[["E"]] <- rnorm(10)
A B D V4 E
r1 1 -1.5795649 e 0.341965486 -1.05802984
r2 2 0.2555095 e 0.201031513 -0.64906076
r3 3 0.6227635 e 0.556581860 -0.57553261
r4 4 0.5079373 e -0.631212107 -1.06903209
r5 5 -0.4499038 e 0.242101746 0.04868978
r6 6 -0.1049976 f -2.391774075 3.79143329
r7 7 -0.7879905 f -0.378202382 -0.73228296
r8 8 -1.7092761 f 1.035118856 -0.37971712
r9 9 -0.6359420 f 0.249394439 1.58841958
r10 10 0.9078611 f 0.006269643 1.08405468Il faut bien sûr que le vecteur contiennent un nombre d’éléments égal au nombre de lignes du data.frame.
Pour ajouter une colonne à mydf qui correspond à la différence des colonnes 1 et 2, il suffit de faire :
mydf[[6]] <- mydf[[1]] - mydf[[2]]
A B D V4 E V6
r1 1 -1.5795649 e 0.341965486 -1.05802984 2.579565
r2 2 0.2555095 e 0.201031513 -0.64906076 1.744490
r3 3 0.6227635 e 0.556581860 -0.57553261 2.377237
r4 4 0.5079373 e -0.631212107 -1.06903209 3.492063
r5 5 -0.4499038 e 0.242101746 0.04868978 5.449904
r6 6 -0.1049976 f -2.391774075 3.79143329 6.104998
r7 7 -0.7879905 f -0.378202382 -0.73228296 7.787991
r8 8 -1.7092761 f 1.035118856 -0.37971712 9.709276
r9 9 -0.6359420 f 0.249394439 1.58841958 9.635942
r10 10 0.9078611 f 0.006269643 1.08405468 9.092139R réalisera la soustraction ligne par ligne.
Il est ici aussi possible de nommer la colonne directement lors de sa création comme montré ci-dessus.
Les notations sont interchangeables ($, [[indice]], [["nom"]]).
Les exercices précédents devraient vous permettre d’utiliser les différentes notations pour extraire des données d’un data.frame. Mais je vous conseille de créer de nouveaux data.frames et d’en extraire différentes parties de différentes façons pour bien être à l’aise.
Il est important de pouvoir identifier facilement les modes et les classes, ainsi que de différencier entre les objets de données, les fonctions et les arguments, pour pouvoir utiliser R.
Voici un résumé :
TRUE/FALSE, alors c’est logique. Facile non ? En cas de doute, la fonction mode() peut être utile.class() et surtout str() sont très utiles.Fonctions : ce sont aussi des objets, mais particuliers. Si vous tapez le nom d’une fonction, vous verrez les opérations que cette fonction effectue :
mean
Mais en général, vous voulez exéctuer les opérations de la fonction. Dans ce cas, il faut utiliser les parenthèses pour grouper et définir les arguments :
mean(1:10)
Les parenthèses sont donc essentielles pour reconnaitre les fonctions.
Arguments : les arguments sont les options de la fonction. Ils sont tous entre les parenthèses de la fonction, séparés par des virgules, et le symbole = permet d’assigner des valeurs aux arguments. Ils peuvent être nommés ou utilisés dans l’ordre défini par la fonction.
Les virgules n’ont donc qu’une seule utilité dans R : séparer les arguments d’une fonction ([ et [[ sont en fait des fonctions).
Et je vous conseille encore de ne garder le = que pour les arguments ; préférez <- pour assigner (cf. 6.2 et 7.4).
L’usage de chaque type est spécifique. Il est important de bien les différencier.
?"[" dans la console. Donc extraire = crochets et vice-versa !if... else.... Nous n’en avons pas parlé, mais vous en aurez forcément besoin un jour sous R.Pour utiliser les fonctions disponibles dans un package, il faut commencer par installer ce dernier. Vous pouvez aller dans les menus, ou taper install.packages("nom du package") dans la console.
Il faut également régulièrement mettre à jour les packages installés, soit en utilisant les menus, soit avec update.packages().
Mais l’installation ne suffit pas pour utiliser les fonctions du package. Il faut ensuite charger ce dernier dans l’espace de travail, en tapant library(nom du package) dans la console (avec ou sans guillemets pour le nom du package).
Une erreur fréquente dans R est : Error: could not find function 'name of function'. Il y a deux possibilités :
Maintenant que vous savez manipuler les objets sous R, vous devriez être capable de transformer un objet pour pouvoir appliquer une fonction dessus. Donc tout ce qu’il vous manque, c’est du vocabulaire.
Voici certaines façons de trouver une fonction pour effectuer une tâche particulière :
apropos() permet de trouver une fonction disponible (c’est-à-dire contenue dans un package chargé) à partir d’une partie de son nom. Essayez par exemple apropos("read"). Cette fonction n’est pas sensible à la casse.help(package="nom du package")??fonction. Avec un point d’interrogation, R cherche l’aide d’une fonction chargée. Avec deux, R cherche l’aide d’une fonction installée. Avec 3, R retourne une erreur. Avec 4… je vous laisse essayer !RSiteSearch() permet de chercher sur une base de données de fonctions et vignettesJe vous joins également un aide mémoire des fonctions utiles par Mayeul Kauffmann.
N’oubliez pas que R ainsi que tout ce qui s’y rapporte est en Anglais !
Une page d’aide est toujours organisée de la même façon. Prenons l’exemple de mean() :
mean {base} (‘base’ indiquant l’installation de base de R)nom argument = valeur par défaut), tandis que d’autre n’ont pas de défaut (seul le nom de l’argument est donné) ; sans défaut, il est obligatoire de fournir une valeur lorsqu’on appelle la fonction.x n’a pas de valeur par défaut, tandis que trim et na.rm en ont (0 et FALSE, respectivement) ; x est donc obligatoire. Si vous ne précisez pas trim et na.rm, alors les valeurs par défaut seront utilisées.Il existe de nombreux livres, blogs, didacticiels… En voici deux qui me semblent pertinents pour commencer :
Il ne faut pas non plus oublier que R permet d’effectuer de nombreux tests statistiques. Je vous invite donc à vous plonger dans ce domaine également !
Voici quelques pistes pour continuer votre apprentissage :
read.table(), read.csv(), read.csv2(), file.choose()readxl et xlsxplot(), boxplot(), par(), package ggplot2plyr et dplyr?regex et fonctions citées?"if"formula()apply(), sapply(), lapply()…print(), cat()is.na(), is.nan()seq(), rep()cbind(), rbind()vector(), length(), which()Si vous êtes arrivé là en ayant tout compris, alors vous ne devriez plus avoir besoin de moi !
Sinon, tous les membres du groupe de R seront prêts à vous aider, n’hésitez pas à nous contacter.
3. Comment installer R ?
Tout est disponible sur le site du R-Project : http://www.r-project.org/
Dans la liste à gauche, cliquer sur ‘CRAN’ (Comprehensive R Archive Network) dans la catégorie ‘Download’ puis choisir un mirroir de téléchargement.
Dans l’encadré ‘Download and Install R’, cliquer sur le lien correspondant au système d’exploitation.
3.1. Windows
Cliquer sur ‘base’ ou ‘install R for the first time’, puis ‘Download R 3.3.1 for Windows’. Télécharger puis exéctuer le fichier d’installation. Suivre les instructions.
Vous pouvez choisir de n’installer que la version 64-bit, et d’installer les traductions de messages (les traductions ne sont pas toujours disponibles ni exactes, mais ça peut aider).
‘Options de démarrage’ : si vous cliquez sur ‘oui’, vous pourrez choisir le mode d’affichage de R, soit dans une seule grande fenêtre (pratique si vous n’avez qu’un écran, mode par défaut), soit dans des fenêtres sépararées (pratique si vous avez 2 écrans).
En plus de R, il est recommandé d’installer RStudio (cf. 3.4).
En cas de problème, contacter Nicolas Stefaniak (nicolas.stefaniak@univ-reims.fr).
3.2. Mac OS
Il est recommandé d’utiliser un ordinateur avec Mac OS 10.9 (Mavericks) ou supérieur, même si les versions à partir de 10.6 (Snow Leopard) sont supportées (l’installation de packages est cependant plus compliquée).
Télécharger le fichier d’installation (‘R-3.3.1.pkg’) et lancer l’installation. Suivre les instructions.
Dans le détail concernant le fichier d’installation, il est expliqué que la dernière version de XQuartz est nécessaire. Télécharger (https://www.xquartz.org/) et installer XQuartz.
Il est également possible d’utiliser RStudio (cf. 3.4), même si cela n’apporte pas grand chose sous Mac pour l’utilisateur moyen.
En cas de problème, me contacter (ivan.calandra@univ-reims.fr).
3.3. Linux
Pour installer R sous Ubuntu (une version LTS (14.04 ou 16.04) est préférable) ou une autre distribution de Linux, il suffit de chercher et installer les paquets r-base et r-base-dev depuis le gestionnaire de paquets.
Il est également possible d’ajouter le site du CRAN à la liste des dépôts, de sorte à ce que les packages de R puissent être téléchargés, installés et mis à jour depuis le gestionnaire de paquets. Consulter la section ‘Download R for Linux’ sur le site https://cran.r-project.org/ pour plus de détails.
En plus de R, il est recommandé d’installer RStudio (cf. 3.4).
En cas de problème, contacter Philippe Regnault (philippe.regnault@univ-reims.fr) ou Frédéric Blanchard (frederic.blanchard@univ-reims.fr).
3.4. RStudio
RStudio est une interface pour R qui améliore notamment les fonctionalités de l’éditeur (couleurs, fermetures automatiques de parenthèses et guillemets, vérification de syntaxe… cf. 5.2) et est particulièrement recommandée pour les utilisateur de Windows et Linux.
Aller sur le site de RStuduio (https://www.rstudio.com/) puis cliquer sur ‘Download RStudio’ puis ‘Download RStudio Desktop’ et télécharger le fichier d’installation correspondant au système d’exploitation (‘RStudio 0.99.903 - …’) dans la catégorie ‘Installers’ en bas de la page. Lancer l’installation et suivre les instructions.