Pour aller plus loin avec R et RStudio
Dans ce tutoriel, nous allons aborder des points plus avancés de l’utilisation de R et RStudio. Nous allons donner quelques éléments sur le package tidyverse, en particulier des librairies ggplot2, dplyr, forcats et stringr qu’il contient. Dans une seconde partie, on abordera l’utilisation de Rmardown pour la rédaction de documents élégants contenant du texte, du code, des résultats d’execution, des expressions mathématiques en latex, …
Le package tidyverse
Principe
Le terme tidyverse est une contraction de tidy (“bien rangé”) et de universe. C’est une collection d’extensions conçues pour travailler ensemble, avec des fonctions de syntaxe cohérente et compatibles, et basées sur une philosophie commune. Ces extensions sont en grande partie dues à Hadley Wickham.
En installant le package tidyverse
, on installe plusieurs extensions qui constituent le “coeur” :
ggplot2
(visualisation)dplyr
(manipulation des données)tidyr
(remise en forme des données)purrr
(programmation)readr
(importation de données)tibble
(tableaux de données)forcats
(variables qualitatives)stringr
(chaînes de caractères)
Elles sont automatiquement chargées avec la commande library(tidyverse)
. On peut aussi les charger une à une (par exemple library(ggplot2)
). La liste complète des extensions de tidyverse se trouve sur le site officiel du tidyverse.
La philosophie de tidyverse est basée sur le concept de tidy data, développé à l’origine par Hadley Wickham dans l’article “Tidy Data.” Journal of Statistical Software (2014). L’idée est d’organiser les données pour faciliter le travail de préparation des données avant l’analyse statistique. Les principes des données tidy sont :
- chaque variable est une colonne
- chaque observation est une ligne
- chaque type d’observation est dans une table différente
Une autre particularité du tidyverse est que les packages de tidyverse travaillent avec des tableaux de données de type tibble
(géré avec le package du même nom), qui est une évolution du format data.frame de R. On peut convertir un data.frame en tibble avec la commande as_tibble()
, et un tibble en data.frame avec as.data.frame()
.
Pour la suite de ce tutoriel, installez et chargez la librairie tidyverse:
Pour la suite, nous utiliserons le jeu de données wine disponible dans le dossier “Data/” , qui nous a déjà servi dans le Tutoriel 3.
Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
1352 medium 1 0.62 0.01 8 46 0.99332 11.8
5493 medium 0 0.34 0.10 17 63 0.99370 9.2
5153 medium 0 0.22 0.22 39 110 0.99855 9.0
5308 medium 0 0.35 0.46 61 183 0.99786 9.0
3866 medium 0 0.42 0.32 20 167 0.99479 10.6
694 medium 1 0.48 0.32 21 122 0.99840 9.4
[1] "data.frame"
[1] TRUE
# A tibble: 600 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 1352 medium 1 0.62 0.01 8 46 0.993 11.8
2 5493 medium 0 0.34 0.1 17 63 0.994 9.2
3 5153 medium 0 0.22 0.22 39 110 0.999 9
4 5308 medium 0 0.35 0.46 61 183 0.998 9
5 3866 medium 0 0.42 0.32 20 167 0.995 10.6
6 694 medium 1 0.48 0.32 21 122 0.998 9.4
7 5085 good 0 0.21 0.32 39 113 0.994 10.2
8 2280 medium 0 0.28 0.14 64 159 0.992 10
9 5231 medium 0 0.3 0.25 21 124 0.994 10.8
10 4388 medium 0 0.4 0.42 41 176 0.996 9.4
# … with 590 more rows
Manipulation de variables qualitatives avec forcats
Les variables qualitatives peuvent être de deux types sous R, character
et factor
, ce qui amène parfois à des erreurs de manipulation et d’utilisation de fonctions non adaptées au type de la variable qualitative étudiée. forcats est une extension de tidyverse qui permet de faciliter la manipulation des variables qualitatives quelque soit leur type. Voici quelques fonctions utiles de forcast
:
fct_recode()
: permet de recoder les modalités d’une variable qualitativefct_collapse()
: permet de regrouper des modalitésfct_other()
: permet de regrouper une liste de modalités dans une seule modalité “Other”fct_lump()
: permet de regrouper automatiquement les modalités les moins fréquentes (seuil modifiable) en une seule modalité “Other”fct_explicit_na()
: permet de recoder les données manquantesNA
en une modalité choisiefct_relevel()
: permet d’ordonner manuellement les modalités d’une variable qualitativefct_reorder()
: permet d’ordonner les modalités d’une variable qualitative en fonction d’une autre variable à laquelle on applique une fonction donnée en argumentfct_infreq()
: permet d’ordonner les modalités selon les effectifs
L’extension questionr propose une interface graphique pour recoder les modalités d’une variable qualitative. On peut aussi se servir de cette interface pour découper une variable quantitative en classes (pour faire comme la fonction cut()
).
library(questionr)
Wine$Type = as.factor(Wine$Type)
Wine$Type = fct_recode(Wine$Type, blanc = "0", rouge = "1")
freq(Wine$Type)
n % val%
blanc 425 70.8 70.8
rouge 175 29.2 29.2
n % val%
bad 19 3.2 3.2
good 110 18.3 18.3
medium 471 78.5 78.5
n % val%
mauvais 19 3.2 3.2
bon 110 18.3 18.3
medium 471 78.5 78.5
n % val%
good 110 18.3 18.3
bad 19 3.2 3.2
medium 471 78.5 78.5
ggplot(Wine) + geom_boxplot(aes(x = fct_reorder(Qualite, Alcool, median), y = Alcool)) +
xlab("Qualite")
Manipulation avec dplyr
dplyr est une extension pour le traitement et la manipulation de données contenues dans un ou plusieurs tableaux. Elle considère que les données sont organisées selon le tidy data, ses fonctions s’appliquent sur des tibble
ou des data.frame
et renvoient le résultat sous forme d’un tibble
. Nous allons illustrer ici les fonctions principales disponibles dans dplyr
.
slice()
La fonction slice()
permet de sélectionner des lignes du tableau selon leur position. Par exemple si on souhaite accéder à la 20ème ligne du jeu de données Wine:
# A tibble: 1 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 6420 medium 0 0.36 0.5 63 178 0.992 9.7
filter()
La fonction filter()
filtre les lignes d’une table selon une condition. Seules les lignes pour lesquelles le test renvoie TRUE
sont conservées.
Par exemple, si on veut ne conserver que les vins de Qualité “medium” :
# A tibble: 471 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 1352 medium 1 0.62 0.01 8 46 0.993 11.8
2 5493 medium 0 0.34 0.1 17 63 0.994 9.2
3 5153 medium 0 0.22 0.22 39 110 0.999 9
4 5308 medium 0 0.35 0.46 61 183 0.998 9
5 3866 medium 0 0.42 0.32 20 167 0.995 10.6
6 694 medium 1 0.48 0.32 21 122 0.998 9.4
7 2280 medium 0 0.28 0.14 64 159 0.992 10
8 5231 medium 0 0.3 0.25 21 124 0.994 10.8
9 4388 medium 0 0.4 0.42 41 176 0.996 9.4
10 4172 medium 0 0.14 0.28 10 56 0.994 9.9
# … with 461 more rows
Si on veut ne conserver que les vins avec au moins 11 degrés d’alcool et une teneur en acide volatile de moins de 0.3 :
# A tibble: 99 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 2155 good 0 0.25 0.34 31 93 0.992 11.3
2 2258 medium 0 0.27 0.25 41 188 0.992 11.3
3 4560 good 0 0.11 0.34 41 114 0.996 11
4 5430 good 0 0.26 0.23 23 111 0.993 11.5
5 6496 good 0 0.290 0.3 20 110 0.989 12.8
6 3046 medium 0 0.27 0.49 35 92 0.991 12.2
7 4690 medium 0 0.17 0.35 33 78 0.991 11.3
8 4799 good 0 0.21 0.4 40 121 0.992 12
9 5167 medium 0 0.26 0.27 20 80 0.991 11.5
10 5291 medium 0 0.22 0.26 23 112 0.993 11.4
# … with 89 more rows
Si on veut filtrer les vins ayant un taux d’alcool entre 10.5 et 11 :
# A tibble: 94 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 3866 medium 0 0.42 0.32 20 167 0.995 10.6
2 5231 medium 0 0.3 0.25 21 124 0.994 10.8
3 4560 good 0 0.11 0.34 41 114 0.996 11
4 3615 medium 0 0.19 0.39 22 84 0.994 10.8
5 2983 medium 0 0.36 0.56 25 102 0.992 10.5
6 6347 medium 0 0.26 0.5 25 93 0.994 10.5
7 3003 good 0 0.26 0.31 29 128 0.994 10.9
8 1291 medium 1 0.74 0 6 12 0.995 11
9 1350 medium 1 0.570 0 21 41 0.995 10.8
10 6336 medium 0 0.16 0.36 13 61 0.991 10.8
# … with 84 more rows
select()
La fonction select()
permet de sélectionner des colonnes d’une table. Nous donnons quelques exemples ci-dessous. On renvoie à l’aide ?select
pour voir les options disponibles pour sélectionner plusieurs colonnes, sélectionner selon une condition sur les noms, … On peut aussi utiliser la fonction rename()
(voir l’aide.)
Dans notre exemple, si on veut récupérer les variables Alcool et Qualite
# A tibble: 600 x 2
Alcool Qualite
<dbl> <chr>
1 11.8 medium
2 9.2 medium
3 9 medium
4 9 medium
5 10.6 medium
6 9.4 medium
7 10.2 good
8 10 medium
9 10.8 medium
10 9.4 medium
# … with 590 more rows
Si on veut éliminer les variables AcidVol et SO2tot :
# A tibble: 600 x 7
rowname Qualite Type AcidCitr SO2lbr Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <dbl>
1 1352 medium 1 0.01 8 0.993 11.8
2 5493 medium 0 0.1 17 0.994 9.2
3 5153 medium 0 0.22 39 0.999 9
4 5308 medium 0 0.46 61 0.998 9
5 3866 medium 0 0.32 20 0.995 10.6
6 694 medium 1 0.32 21 0.998 9.4
7 5085 good 0 0.32 39 0.994 10.2
8 2280 medium 0 0.14 64 0.992 10
9 5231 medium 0 0.25 21 0.994 10.8
10 4388 medium 0 0.42 41 0.996 9.4
# … with 590 more rows
Si on veut récupérer les colonnes dont le nom commence par Acid
# A tibble: 600 x 2
AcidVol AcidCitr
<dbl> <dbl>
1 0.62 0.01
2 0.34 0.1
3 0.22 0.22
4 0.35 0.46
5 0.42 0.32
6 0.48 0.32
7 0.21 0.32
8 0.28 0.14
9 0.3 0.25
10 0.4 0.42
# … with 590 more rows
Si on veut récupérer les colonnes qui contiennent Acid :
# A tibble: 600 x 2
AcidVol AcidCitr
<dbl> <dbl>
1 0.62 0.01
2 0.34 0.1
3 0.22 0.22
4 0.35 0.46
5 0.42 0.32
6 0.48 0.32
7 0.21 0.32
8 0.28 0.14
9 0.3 0.25
10 0.4 0.42
# … with 590 more rows
arrange()
La fonction `arrange()
permet de réordonner les lignes du jeu de données en fonction d’une ou plusieurs variables.
Par exemple, pour ordonner les lignes de Wine en fonction des valeurs de la variable Alcool
# A tibble: 600 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 4225 medium 0 0.19 0.21 89 159 0.993 8
2 3185 medium 0 0.3 0.74 46 165 0.998 8.7
3 2830 medium 0 0.290 0.3 46 238 0.999 8.7
4 5650 good 0 0.16 0.27 25 135 0.998 8.7
5 5278 medium 0 0.23 0.25 19 111 1.00 8.7
6 1741 medium 0 0.37 0.67 49 155 0.998 8.7
7 1684 medium 0 0.43 0.61 54 155 0.997 8.7
8 1737 medium 0 0.37 0.67 49 155 0.998 8.7
9 3258 medium 0 0.31 0.49 52 220 0.996 8.8
10 1477 medium 1 0.5 0.5 48 82 1.00 8.8
# … with 590 more rows
Pour trier par ordre décroissant, on utilise la fonction desc()
# A tibble: 600 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 5504 good 0 0.455 0.18 33 106 0.987 14
2 6389 medium 0 0.62 0.33 24 118 0.988 13.6
3 5729 good 0 0.34 0.31 18 68 0.990 13.4
4 5103 good 0 0.33 0.31 21 93 0.990 13.4
5 5795 good 0 0.45 0.24 24 87 0.989 13.4
6 492 good 1 0.41 0.5 12 25 0.995 13.3
7 4973 good 0 0.28 0.24 49 121 0.989 13.2
8 6437 medium 0 0.28 0.38 54 216 0.992 13.1
9 5099 good 0 0.33 0.3 30 124 0.989 13.1
10 1288 medium 1 0.6 0.08 3 7 0.993 13
# … with 590 more rows
Pour trier selon les deux variables Qualite et Alcool :
# A tibble: 600 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 5812 bad 0 0.31 0.37 13 164 0.996 8.8
2 3937 bad 0 0.28 0.35 61 180 0.997 9
3 460 bad 1 0.580 0.66 10 47 1.00 9
4 2226 bad 0 0.56 0.12 22 177 0.998 9.1
5 2262 bad 0 0.570 0.1 23 188 0.997 9.2
6 4131 bad 0 0.54 0.27 8 178 0.995 9.4
7 3074 bad 0 0.25 0.24 13 85 0.994 9.5
8 1646 bad 0 0.45 0.26 63 206 0.994 9.8
9 4000 bad 0 0.19 0.42 16 104 0.995 10
10 4001 bad 0 0.16 0.49 18 107 0.995 10.2
# … with 590 more rows
On peut remarquer que l’on obtient le même résultat avec la commande
# A tibble: 600 x 9
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 5812 bad 0 0.31 0.37 13 164 0.996 8.8
2 3937 bad 0 0.28 0.35 61 180 0.997 9
3 460 bad 1 0.580 0.66 10 47 1.00 9
4 2226 bad 0 0.56 0.12 22 177 0.998 9.1
5 2262 bad 0 0.570 0.1 23 188 0.997 9.2
6 4131 bad 0 0.54 0.27 8 178 0.995 9.4
7 3074 bad 0 0.25 0.24 13 85 0.994 9.5
8 1646 bad 0 0.45 0.26 63 206 0.994 9.8
9 4000 bad 0 0.19 0.42 16 104 0.995 10
10 4001 bad 0 0.16 0.49 18 107 0.995 10.2
# … with 590 more rows
Cette commande pipe %>%
est importante dans dplyr.
Le pipe %>%
On est souvent amené à enchaîner plusieurs opérations sur un tableau. Par exemple,
# A tibble: 205 x 2
Qualite Alcool
<chr> <dbl>
1 bad 11.5
2 bad 11.6
3 bad 11.5
4 bad 11.2
5 bad 11.2
6 good 12.7
7 good 11.3
8 good 11
9 good 11.5
10 good 12.8
# … with 195 more rows
mais cet enchainement de fonctions est peu lisible. On peut améliorer la lisibilité du code en utilisant le pipe, noté %>%
. Si on execute `expr%>%f
, le résultat de expr
est passé comme premier argument de la fonction f
, ce qui revient à executer f(expr)
. Ainsi notre exemple précédent peut se réécrire avec le code suivant :
# A tibble: 205 x 2
Qualite Alcool
<chr> <dbl>
1 bad 11.5
2 bad 11.6
3 bad 11.5
4 bad 11.2
5 bad 11.2
6 good 12.7
7 good 11.3
8 good 11
9 good 11.5
10 good 12.8
# … with 195 more rows
if_else()
/ case_when()
Ces fonctions permettent de créer une nouvelle variable à partir d’une ou plusieurs variables existantes en faisant un ou des tests. La fonction if_else()
prend en argument un test, une valeur à renvoyer si le test est vrai, et une valeur à renvoyer si le test est faux. case_when()
généralise if_else()
en permettant de considérer plusieurs tests et leurs valeurs associées en même temps. Mais attention, les conditions étant testées l’une après l’autre, l’ordre des tests est important.
[,1] [,2]
[1,] "11.8" "Alcool sup. à 11"
[2,] "9.2" "Alcool inf. à 11"
[3,] "9" "Alcool inf. à 11"
[4,] "9" "Alcool inf. à 11"
[5,] "10.6" "Alcool inf. à 11"
[6,] "9.4" "Alcool inf. à 11"
new <- case_when(Wine$Alcool > 11 & Wine$Type == "rouge" ~ "vins rouges de degré sup. à 11",
Wine$Alcool > 11 & Wine$Type == "blanc" ~ "vins blancs de degré sup. à 11",
TRUE ~ "Autre")
freq(new)
n % val%
Autre 413 68.8 68.8
vins blancs de degré sup. à 11 142 23.7 23.7
vins rouges de degré sup. à 11 45 7.5 7.5
group_by()
La fonction group_by()
permet de créer des groupes de lignes à partir des valeurs d’une ou plusieurs variables. Par exemple on peut regrouper les vins selon leur qualité :
# A tibble: 600 x 9
# Groups: Qualite [3]
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 1352 medium 1 0.62 0.01 8 46 0.993 11.8
2 5493 medium 0 0.34 0.1 17 63 0.994 9.2
3 5153 medium 0 0.22 0.22 39 110 0.999 9
4 5308 medium 0 0.35 0.46 61 183 0.998 9
5 3866 medium 0 0.42 0.32 20 167 0.995 10.6
6 694 medium 1 0.48 0.32 21 122 0.998 9.4
7 5085 good 0 0.21 0.32 39 113 0.994 10.2
8 2280 medium 0 0.28 0.14 64 159 0.992 10
9 5231 medium 0 0.3 0.25 21 124 0.994 10.8
10 4388 medium 0 0.4 0.42 41 176 0.996 9.4
# … with 590 more rows
Dans l’affichage, on voit apparaitre “Groups” dans les premières lignes, le reste n’a pas changé. Mais une fois les groupes créés, ils peuvent être utilisés dans les différentes fonctions de dplyr
SAUF pour arrange()
.
Si on veut grouper selon plusieurs variables, il suffit de les passer en argument de group_by()
:
# A tibble: 600 x 9
# Groups: Qualite, Type [6]
rowname Qualite Type AcidVol AcidCitr SO2lbr SO2tot Densite Alcool
<chr> <chr> <int> <dbl> <dbl> <dbl> <int> <dbl> <dbl>
1 1352 medium 1 0.62 0.01 8 46 0.993 11.8
2 5493 medium 0 0.34 0.1 17 63 0.994 9.2
3 5153 medium 0 0.22 0.22 39 110 0.999 9
4 5308 medium 0 0.35 0.46 61 183 0.998 9
5 3866 medium 0 0.42 0.32 20 167 0.995 10.6
6 694 medium 1 0.48 0.32 21 122 0.998 9.4
7 5085 good 0 0.21 0.32 39 113 0.994 10.2
8 2280 medium 0 0.28 0.14 64 159 0.992 10
9 5231 medium 0 0.3 0.25 21 124 0.994 10.8
10 4388 medium 0 0.4 0.42 41 176 0.996 9.4
# … with 590 more rows
summarise()
La fonction summarise()
permet de calculer quelques indicateurs statistiques sur une ou plusieurs variables. Par exemple, si on veut connaitre la teneur moyenne en acide volatile de tous les vins
# A tibble: 1 x 1
AcidVolmean
<dbl>
1 0.351
Si on veut maintenant la teneur moyenne en acide volatile sur tous les vins regroupés par qualité :
# A tibble: 3 x 2
Qualite AcidVolmean
<chr> <dbl>
1 bad 0.423
2 good 0.303
3 medium 0.360
On veut également calculer la teneur en acide volatile minimale et maximale dans chaque groupe :
Wine.tbl %>% group_by(Qualite) %>% summarise(AcidVolmean = mean(AcidVol, na.rm = T),
AcidVolmin = min(AcidVol, na.rm = T), AcidVolmax = max(AcidVol, na.rm = T))
# A tibble: 3 x 4
Qualite AcidVolmean AcidVolmin AcidVolmax
<chr> <dbl> <dbl> <dbl>
1 bad 0.423 0.16 0.63
2 good 0.303 0.1 0.915
3 medium 0.360 0.12 1.04
summarise()
possède un opérateur n()
pour connaître le nombre de lignes par groupe :
# A tibble: 3 x 2
Qualite nb
<chr> <int>
1 bad 19
2 good 110
3 medium 471
n()
peut aussi être utilisé avec filter()
et mutate()
. On peut aussi directement utiliser la fonction count()
# A tibble: 3 x 2
Qualite n
<chr> <int>
1 bad 19
2 good 110
3 medium 471
mutate() / transmute()
mutate()
permet de créer de nouvelles variables (colonnes) dans le tableau en conservant toutes les autres variables existantes. Par exemple, si on convertit la densité, qui est donnée en g/cm3, en mg/cm3 :
# A tibble: 600 x 2
Densite densmg
<dbl> <dbl>
1 0.993 993.
2 0.994 994.
3 0.999 999.
4 0.998 998.
5 0.995 995.
6 0.998 998.
7 0.994 994.
8 0.992 992
9 0.994 994.
10 0.996 996.
# … with 590 more rows
La fonction transmute()
permet également d’ajouter une variable mais en supprimant les autres cette fois.
Manipulation de chaines de caractère avec stringr
stringr est une extension pour la manipulation de chaînes de caractères. On présente ici les fonctions les plus utilisées, qui seront illustrées sur l’exemple suivant :
ExChaine <- tibble(nom = c("M. Gérard MARTIN", "Mme Marie DUPONT", "M. Rémi THOMAS"),
adresse = c("30 avenue de la République", "40 rue de la Libération", "2 impasse des pivoines"),
ville = c("Toulouse", "Marseille", "Bordeaux"))
ExChaine
# A tibble: 3 x 3
nom adresse ville
<chr> <chr> <chr>
1 M. Gérard MARTIN 30 avenue de la République Toulouse
2 Mme Marie DUPONT 40 rue de la Libération Marseille
3 M. Rémi THOMAS 2 impasse des pivoines Bordeaux
Pour plus de détails vous pouvez vous référer au chapitre 14 du livre de Wickham, H. et G. Grolemund (2016) dédié à la librairie stringr
ainsi qu’au site web officiel de stringr.
str_length()
La fonction str_length()
permet d’obtenir la longueur d’une chaîne / tableau de caractères :
[1] 59 84 38
str_c()
La fonction str_c()
est la fonction de stringr
dédiée à la concaténation des chaines de caractères. On a déjà vu la fonction paste()
de R. Voici quelques exemples :
[1] "M. Gérard MARTIN Toulouse" "Mme Marie DUPONT Marseille"
[3] "M. Rémi THOMAS Bordeaux"
[1] "M. Gérard MARTIN/-/Toulouse" "Mme Marie DUPONT/-/Marseille"
[3] "M. Rémi THOMAS/-/Bordeaux"
[1] "M. Gérard MARTIN Toulouse" "Mme Marie DUPONT/---/Marseille"
[3] "M. Rémi THOMAS!!!Bordeaux"
str_to_lower()
/ str_to_upper')
/ str_to_title()
Les fonctions str_to_lower()
, str_to_upper()
et str_to_title()
permettent de mettre en minuscules, en majuscules, ou en lettres capitales respectivement les éléments d’une chaînes de caractères
[1] "m. gérard martin" "mme marie dupont" "m. rémi thomas"
[1] "M. GÉRARD MARTIN" "MME MARIE DUPONT" "M. RÉMI THOMAS"
[1] "M. Gérard Martin" "Mme Marie Dupont" "M. Rémi Thomas"
str_sub()
/ str_extract()
La fonction str_sub()
permet d’extraire des sous-chaînes de caractères en indiquant les positions des premier et dernier caractères :
[1] " Gérard" "e Marie" " Rémi T"
[1] " Gérard MARTIN" "e Marie DUPONT" " Rémi THOMAS"
La fonction str_extract()
permet d’extraire les valeurs correspondant à un motif.
[1] NA "pivoines" NA
Plus subtil, cette commande permet de récupérer tous les numéros des adresses :
[1] "30" "40" "2"
Pour aller plus loin, vous pouvez consulter les références donner pour la librairie stringr
.
str_detect()
La fonction str_detect()
permet de détecter la présence d’un motif parmi les élements d’un vecteur de caractères. Elle renvoie un vecteur de booléens.
[1] FALSE FALSE FALSE
[1] TRUE TRUE FALSE
[1] TRUE TRUE TRUE
La fonction str_count()
dénombre les occurences d’un motif dans un vecteur de caractères.
[1] 2 1 0
[1] 3 1 1
str_split()
La fonction str_split()
permet de découper une chaîne de caractère (premier argument) en fonction d’un délimiteur (second argument).
[[1]]
[1] "c(\"M." "Gérard" "MARTIN\"," "\"Mme" "Marie" "DUPONT\","
[7] "\"M." "Rémi" "THOMAS\")"
[[2]]
[1] "c(\"30" "avenue" "de" "la"
[5] "République\"," "\"40" "rue" "de"
[9] "la" "Libération\"," "\"2" "impasse"
[13] "des" "pivoines\")"
[[3]]
[1] "c(\"Toulouse\"," "\"Marseille\"," "\"Bordeaux\")"
[[1]]
[1] "M." "Gérard" "MARTIN"
[[2]]
[1] "Mme" "Marie" "DUPONT"
[[3]]
[1] "M." "Rémi" "THOMAS"
[[1]]
[1] "M. Gé" "a" "d MARTIN"
[[2]]
[1] "Mme Ma" "ie DUPONT"
[[3]]
[1] "M. Rémi THOMAS"
On peut également l’appliquer sur un tableau en ajoutant l’option simplify = TRUE
.
str_replace()
La fonction str_replace()
permet de remplacer une chaîne ou un motif par une autre.
[1] "M. Gérard MARTIN" "Mme Marie DUPONT" "M. Rémi THOMAS"
Pour spécifier plusieurs remplacements d’un coup, on peut utiliser str_replace_all()
[1] "30 Av. de la République" "40 Rue de la Libération"
[3] "2 Imp. des pivoines"
Visualisation avec ggplot2
ggplot2 est une extension dédiée aux graphiques. Elle est basée sur une syntaxe particulière (il faut oublier les graphiques de base de R) mais robuste et efficace pour la construction de graphiques complexes. Elle demande donc un peu d’investissement pour se familiariser avec la syntaxe. Elle part du principe (comme tout package de tidyverse) que les données relatives au graphique sont stockées dans un tableau (data.frame ou tibble). Pour plus de détails, on peut consulter le livre “Ggplot2: Elegant Graphics for Data Analysis” de Wickham (2016) et le site web de ggplot2.
Un graphique en ggplot2
s’initialise avec la fonciton ggplot()
qui prend en argument le jeu de données étudié. Par exemple, pour le jeu de données Wine,
Pour l’instant, on ne voit rien mais pourtant l’objet gEx
contient des informations :
data: Qualite, Type, AcidVol, AcidCitr, SO2lbr, SO2tot, Densite, Alcool
[600x8]
faceting: <ggproto object: Class FacetNull, Facet, gg>
compute_layout: function
draw_back: function
draw_front: function
draw_labels: function
draw_panels: function
finish_data: function
init_scales: function
map_data: function
params: list
setup_data: function
setup_params: function
shrink: TRUE
train_scales: function
vars: function
super: <ggproto object: Class FacetNull, Facet, gg>
[1] "data" "layers" "scales" "mapping" "theme"
[6] "coordinates" "facet" "plot_env" "labels"
list()
mais pour l’instant son layers
est vide.
On ajoute ensuite des éléments graphiques, appelés geom
, à l’objet graphique grâce à l’opérateur +
et on précise à l’aide de la fonction aes()
les données à utiliser en argument du geom
. Par exemple, si on veut faire l’histogramme de la variable Alcool
On peut également ajouter un mappage, c’est à dire une mise en relation entre un attribut graphique d’un geom et une variable du tableau de données. Par exemple, on peut mettre des couleurs à un nuage de points en fonction d’une variable qualitative, … Il faut bien distinguer un mappage d’une modification d’un attribut graphique sans lien avec une variable. Une règle importante à retenir est donc
- pour définir un mappage (relation entre les valeurs d’une variable et un attribut graphique), on le déclare dans
aes()
- pour modifier un attribut graphique de la même manière pour tous les points, on le définit en-dehors de la fonction
aes()
.
Dans la présentation qui suit des geom
usuels, on proposera quelques illustrations de mappages. Chaque geom
a sa liste de mappages possibles.
Les geom
usuels
Nous allons ici présenter les geom
les plus connus.
geom_histogram()
geom_histogram()
permet de représenter l’histogramme d’une variable quantitative.
geom_point()
geom_point()
permet de représenter un nuage de points. Il faut préciser la position en x (la variable sur l’axe horizontal) et en y (la variable sur l’axe vertical) de ces points dans aes()
.
On peut modifier certains attributs de ce graphique comme la couleur des points (color
), la taille des points (size
), leur transparence (alpha
).
geom_boxplot()
geom_boxplot()
permet de représenter des boxplot (boites à moustaches). On lui précise en y la variable quantitative dont on veut étudier la répartition, et en x la variable qualitative contenant les groupes à comparer.
Vous pouvez vous référer à l’aide et la documentation en ligne pour ensuite améliorer ce graphique en modifiant certaines options.
geom_violin()
geom_violin()
est très proche de la représentation boxplot mais utilise la représentation en violon plutôt que la boite à moustaches, ce qui permet de mieux visualiser la distribution des données.
geom_bar()
geom_bar()
permet la représentation en batôns (barplot) d’une variable qualitative (précisée en argument x
à aes()
).
On peut modifier le visuel en changeant certaines options. Par exemple,
ggplot(data = Wine) + geom_bar(aes(x = Qualite, y = ..prop.., group = 1), fill = "darkblue",
width = 0.5)
On peut aussi obtenir la représentation en camembert en modifiant un peu le graphique en baton en passant en “coordonnées polaires”
geom_density()
geom_density()
permet de représenter l’estimation de la densité d’une variable quantitative. Son utilisation est similaire à geom_histogram()
.
Pour aller plus loin
Représentations de plusieurs geom
On peut représenter plusieurs geom sur un même graphique simultanément, il suffit d’utiliser l’opérateur +
pour les ajouter au fur et à mesure. On donne ici quelques exemples pour illustrer.
Faceting
faceting est le terme pour faire un même graphique plusieurs fois selon les modalités d’une ou des variable(s) qualitative(s). On peut utiliser les fonctions facet_wrap()
et facet_grid()
qui prennent une variable
qualitative sous la forme d’une formule ~variable
. Les différents graphiques sont affichés les uns à côtés des autres avec facet_wrap()
et selon une grille avec facet_grid()
(prend une formule variable ligne ~ variable colonne
).
Les scales
Les scales permettent de modifier la façon dont un attribut graphique est lié aux valeurs d’une variable. Pour les modifier, on ajoute un nouvel élément de la forme scale_<attribut>_<type>
à l’objet graphique ggplot2 avec +
. Les fonctions scale les plus connues sont :
scale_size()
(avec son argumentrange
) pour modifier les tailles minimales, maximales, …scale_x()
etscale_y()
pour modifier l’axex
et l’axey
respectivementscale_x_continuous()
(resp.scale_x_discrete()
) pour modifier l’axe desx
dans le cas d’une variable quantitative (resp. une variable qualitative)scale_y_continuous()
(resp.scale_y_discrete()
) pour modifier l’axe desy
dans le cas d’une variable quantitative (resp. une variable qualitative)scale_color()
pour modifier les couleurs de dessinscale_fill()
pour modifier les couleurs de remplissage
Pour les couleurs, on peut spécifier un gradient de couleur sur une variable quantitative avec scale_color_gradient()
, modifier manuellement la palette de couleur avec scale_color_manual()
, faire appel à une palette de couleur prédéfinie (par exemple en utilisant le package viridis avec scale_color_viridis
, en s’appuyant sur les palettes disponibles dans ColorBrewer avec scale_color_brewer()
), …
Thèmes
Les thèmes permettent de gérer l’affichage des éléments graphiques non liés aux données comme les titres, les fonds, les grilles, … Il existe plusieurs thèmes prédéfinis comme theme_classic()
, theme_minimal()
et theme_bw()
. On a aussi le package ggthemes
qui fournit d’autres thèmes par exemple.
g = ggplot(data = Wine) + geom_point(aes(x = Alcool, y = Densite))
g1 = g + theme_classic()
g2 = g + theme_minimal()
g3 = g + theme_bw()
grid.arrange(g1, g2, g3, ncol = 3)
On peut modifier chaque élément séparément avec une commande spécifique, par exemple :
ggtitle()
pour modifier le titrexlab()
etylab()
pour modifier l’intituler de l’axe des abscisses et des ordonnées respectivement
Avec la fonction theme()
, on peut contrôler les éléments graphiques incluant :
- les éléments linéaires (
element_line()
): traits des axes, traits des grilles mineur et majeur, bordure du panneau graphique, graduation des axes, couleurs de fond, … - les éléments textuels (
element_text()
): titre du graphique et des axes, titre et textes de la légende, les étiquettes des graduations des axes, … - les éléments rectangulaires (
element_rect()
) : arrière plan du graphique, du panneau et de la légende, … Les fonctions entre parenthèses sont spécifiques pour modifier chacun de ces trois éléments.
En bref, les possibles avec ggplot2 sont infinis car de nombreux éléments sont personnalisables. Un moyen pour maitriser toutes ces possibilités est l’utilisation de l’addin RStudio ggThemeAssist
. Pour cela, il faut installer le package ggThemeAssist
, de sélectionner le code correspondant à un graphique ggplot2 et d’aller dans le menu Addins pour choisir ggplot Theme Assistant. Une interface graphique s’ouvre alors, permettant de modifier différents éléments du graphique et d’en récupérer le code correspondant.
Packages complémentaires et documentations
On donne ici une liste non exhaustive de packages que l’on peut utiliser en complément de ggplot2 :
- Le package plotly permet d’avoir des graphiques interactifs. On peut par exemple utiliser la fonction
ggplotly()
sur un graphique ggplot2 - Le package gridExtra permet d’organiser plusieurs graphiques sur une même fenêtre graphique. On peut par exemple utiliser la fonction
grid.arrange()
.
- Le package cowplot contient des fonctionnalités qui permettent d’avoir des graphiques de qualité pour des publications, en particulier pour l’organisation de plusieurs graphiques.
- Le package esquisse est un package qui fournit une interface graphique pour la construction de graphiques avec ggplot2.
library(plotly)
g = ggplot(Wine, aes(x = Alcool, y = Densite)) + geom_point() + geom_smooth()
ggplotly(g)
Nous donnons ici quelques références pour les graphiques en ggplot2 mais il existe de nombreuses ressources sur le web:
- Le livre Ggplot2: Elegant Graphics for Data Analysis de H. Wickham. (Wickham 2016)
- Le site web de ggplot2
- The R Graph Gallery
- The Cheat Sheet de ggplot 2
Le package rmarkdown
L’extension Rmarkdown permet de créer des documents dans différents formats (html, pdf, docx, slides, …) qui contiennent du texte, du code (en R mais pas que!), les résultats, … Par exemple, les tutoriels de ce cours ont été rédigés avec Rmarkdown. L’utilisation de Rmarkdown permet d’obtenir un document final reproductible, associant code, résultats et commentaires. Le document peut être facilement regénéré et mis à jour (par exemple si les données étudiées ont été modifiées).
Nous allons donner ici des éléments de base pour la création de documents avec Rmarkdown. Pour plus de détails, vous pouvez consulter par exemple le livre en ligne R Markdown: The Definitive Guide de Y. Xie, J. J. Allaire, G. Grolemund. (2018)
Etapes de création d’un document
Un document Rmarkdown est un fichier enregistré avec l’extension .Rmd
. Pour créer un nouveau document, allez dans File-> NewFile-> Rmarkdown...
(ou cliquez sur l’icone nouveau document et choisissez Rmarkdown). La boîte de dialogue suivante s’ouvre :
Vous pouvez choisir le format du fichier final souhaité, préciser le titre et l’auteur (qui peuvent être modifiés ensuite si besoin). On peut remarquer que l’on peut aussi faire des présentations avec Rmarkdown et on peut utiliser des templates existants (par exemple ce tutoirel utilise le template readthedown du package rmdformats
.)
Exercice :
Créez un nouveau document Rmarkdown au format html avec le titre et l’auteur de votre choix. Vous pouvez constater qu’un nouveau document prérempli vient de s’ouvrir dans RStudio. Nous allons maintenant détailler le contenu de ce document.
Un document Rmarkdown débute toujours par l’en-tête qui est encadré par 3 tirets ---
. Cet en-tête contient les métadonnées du document : le titre, l’auteur, la date, le format de sortie (output
). Quelques éléments seront précisés dans la section Contenu de l’en-tête.
On a ensuite le corps du document qui peut contenir
- du texte selon la syntaxe markdown (voir la section Quelques éléments markdown)
- des blocs de code (appelés chunks) en R, Python, … (voir la section Options des blocs de code)
- des formules mathématiques (écrites en latex entre
$ ... $
) - des images, tableaux, références, ….
Vous pouvez compiler à tout moment le document Rmarkdown en cliquant sur le bouton et de choisir le format de sortie voulu. Un onglet R Markdown s’ouvre alors dans la même zone que l’onglet Console pour indiquer la progression de la compilation et les messages d’erreur éventuels. Une fois la compilation effectuée, le document obtenu s’ouvre et vous pouvez admirer le rendu. Vous pouvez personnaliser le document de sortie en cliquant sur l’icone et en choisissant Output Options...
.
Remarque:
Pour la compilation d’un document en pdf, il est nécessaire d’avoir installé un compilateur de Latex sur son ordinateur. Si ce n’est pas le cas, vous pouvez utiliser l’extension
tinytex
(voir ici pour plus de détails)
Contenu de l’en-tête
Un document Rmarkdown débute par un en-tête entre ---
au format YAML contenant les métadonnées du document. Voici un exemple de base de préambule :
Ici output: html_document
indique le document final généré sera au format html. On peut modifier cette option par pdf_document
pour un document pdf, word_document
pour docx, et bien d’autres possibilités.
En executant la fonction Sys.Date()
pour l’option date
, la date sera remise à jour automatiquement à chaque compilation du document.
On peut préciser des options au document final en ajoutant des sous-options à droite du output
. Il est également possible de spécifier des options différentes selon les formats. Voici un exemple :
---
title: "Titre"
author: "Prénom Nom"
date: "`r Sys.Date()`"
output:
html_document :
toc : TRUE
toc_float : TRUE
number_sections : TRUE
fig_width : 4
pdf_document :
fig_caption: TRUE
highlight: kate
---
Voici une liste avec quelques éléments :
number_section : true
permet de numéroter les sectionshighlight
permet de spécifier le style syntaxique (par exdefault
,tango
,pygments
,kate
, …).- on peut ajouter son propre fichier de style .css avec l’option
css
- on peut préciser des options concernant les figures avec
fig_width
,fig_height
,fig_caption
,dev
, … - on peut ajouter une bibliographie à partir d’un fichier
.bib
avec l’optionbibliography
Si vous utilisez la boite de dialogue des options du document de sortie Output Options ...
, l’en-tête sera remis à jour pour suivre les options choisies.
Pour plus de détails voir le site détaillant les R Markdown formats et l’aide mémoire de Rmarkdown (accessible via Help -> Cheatsheets -> Rmarkdown Cheat Sheet
).
Exercice :
Créez un nouveau fichier Rmarkdown et enregistrez-le. Modifiez les options dans l’en-tête et compilez le document pour constater l’impacxt sur le document généré
Quelques éléments markdown
Le texte d’un document Rmarkdown est régi par le langage markdown. Voici quelques éléments de syntaxe et de mise en forme
Remarque: Si vous avez organisé votre document avec des sections / sous-sections en faisant débuter une ligne par un ou plusieurs #
, alors vous pouvez cliquer sur l’icone à droite de la barre d’outils associée au fichier R Markdown pour visualiser la table des matières générée automatiquement qui vous permet de naviguer facilement dans le document.
Pour plus de détails, on peut aller voir
- sous RStudio, allez dans
Help -> Markdown Quick Reference
: une fenêtre d’aide en bas à droite s’ouvre donnant les bases de syntaxe markdown - sous RStudio, allez dans
Help -> Cheatsheets -> R Markdown Cheat Sheet
qui permet d’aller consulter le document suivant. On retrouve des éléments en deuxième page. - Consulter la page web du markdown guide
Options des blocs de code (chunks)
Pour insérer du code dans un document Rmarkdown, on utilise des blocs appelés chunk. Pour cela, il suffit de cliquer sur l’icone d’insertion d’un chunk dans la barre d’outils d’un document Rmarkdown. Il est possible d’insérer un chunk de code R mais pas seulement (par exemple on peut insérer du code Python). Pour du code R, un chunk de cette forme s’insère alors dans le document
On peut alors saisir du code R dans ce chunk. On peut ajouter un nom à un bloc juste après r
({r nomdubloc}
). On peut également préciser des options dans les accolades {r nomdubloc, ....}
, par exemple
Ces options peuvent être modifiées manuellement ou en utilisant l’interface graphique (en cliquant sur l’icone d’engrenage situé en haut à droite de chaque bloc).
Lorsque l’on veut appliquer une (des) option(s) à l’ensemble des blocs du document, on utilise la fonction knitr::opts_chunk$set()
dans un bloc spécial appelé setup
et qui est le premier bloc du document:
References
Wickham, H. 2016. Ggplot2: Elegant Graphics for Data Analysis. springer.
Wickham, H., and G. Grolemund. 2016. R for Data Science: Import, Tidy, Transform, Visualize, and Model Data. " O’Reilly Media, Inc.". https://r4ds.had.co.nz/.
Wickham, H., and others. 2014. “Tidy Data.” Journal of Statistical Software 59 (10): 1–23.
Xie, Y., J. J. Allaire, and G. Grolemund. 2018. R Markdown: The Definitive Guide. CRC Press.