forked from juba/tidyverse
-
Notifications
You must be signed in to change notification settings - Fork 0
/
06-tidyverse.Rmd
139 lines (90 loc) · 5.78 KB
/
06-tidyverse.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# (PART) Introduction au tidyverse {-}
# Le tidyverse {#tidyverse}
```{r include = FALSE}
library(tibble)
library(questionr)
```
## Extensions
Le terme *tidyverse* est une contraction de *tidy* (qu'on pourrait traduire par "bien rangé") et de *universe*. Il s'agit en fait d'une collection d'extensions conçues pour travailler ensemble et basées sur une philosophie commune.
Elles abordent un très grand nombre d'opérations courantes dans R (la liste n'est pas exhaustive) :
- visualisation
- manipulation des tableaux de données
- import/export de données
- manipulation de variables
- extraction de données du Web
- programmation
Un des objectifs de ces extensions est de fournir des fonctions avec une syntaxe cohérente, qui fonctionnent bien ensemble, et qui retournent des résultats prévisibles. Elles sont en grande partie issues du travail d'[Hadley Wickham](http://hadley.nz/), qui travaille désormais pour [RStudio](https://www.rstudio.com).
## Installation
`tidyverse` est également le nom d'une extension qu'on peut installer de manière classique, soit via le bouton *Install* de l'onglet *Packages* de RStudio, soit en utilisant la commande :
```{r eval=FALSE}
install.packages("tidyverse")
```
Cette commande va en fait installer plusieurs extensions qui constituent le "coeur" du *tidyverse*, à savoir :
- `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)
De la même manière, charger l'extension avec :
```{r eval=FALSE}
library(tidyverse)
```
Chargera l'ensemble des extensions précédentes.
Il existe d'autres extensions qui font partie du *tidyverse* mais qui doivent être chargées explicitement, comme par exemple `readxl` (pour l'importation de données depuis des fichiers Excel).
La liste complète des extensions se trouve sur [le site officiel du *tidyverse*](https://www.tidyverse.org/packages/).
Ce document est basé sur les versions d'extension suivantes :
```{r echo=FALSE, message=TRUE, warning=TRUE}
core <- tidyverse:::core
versions <- vapply(core, tidyverse:::package_version, character(1))
packages <- paste0(
crayon::blue(format(core)), " ",
crayon::col_align(versions, max(crayon::col_nchar(versions)))
)
if (length(packages) %% 2 == 1) {
packages <- append(packages, "")
}
col1 <- seq_len(length(packages) / 2)
info <- paste0(packages[col1], " ", packages[-col1])
tidyverse:::msg(paste(info, collapse = "\n"), startup = TRUE)
```
## tidy data {#tidydata}
Le *tidyverse* est en partie fondé sur le concept de *tidy data*, développé à l'origine par Hadley Wickham dans un [article de 2014](https://www.jstatsoft.org/article/view/v059i10) du *Journal of Statistical Software*.
Il s'agit d'un modèle d'organisation des données qui vise à faciliter le travail souvent long et fastidieux de nettoyage et de préparation préalable à la mise en oeuvre de méthodes d'analyse.
Les principes d'un jeu de données *tidy* sont les suivants :
1. chaque variable est une colonne
2. chaque observation est une ligne
3. chaque type d'observation est dans une table différente
On verra plus précisément dans la section \@ref(tidyr) comment définir et rendre des données *tidy* avec l'extension `tidyr`.
Les extensions du tidyverse, notamment `ggplot2` et `dplyr`, sont prévues pour fonctionner avec des données *tidy*.
## tibbles {#tibbles}
Une autre particularité du *tidyverse* est que ces extensions travaillent avec des tableaux de données au format *tibble*, qui est une évolution plus moderne du classique *data frame* du R de base. Ce format est fourni est géré par l'extension du même nom (`tibble`), qui fait partie du coeur du *tidyverse*. La plupart des fonctions des extensions du *tidyverse* acceptent des *data frames* en entrée, mais retournent un objet de classe `tibble`.
Contrairement aux *data frames*, les *tibbles* :
- n'ont pas de noms de lignes (*rownames*)
- autorisent des noms de colonnes invalides pour les *data frames* (espaces, caractères spéciaux, nombres...) ^[Quand on veut utiliser des noms de ce type, on doit les entourer avec des *backticks* (`)]
- s'affichent plus intelligemment que les *data frames* : seules les premières lignes sont affichées, ainsi que quelques informations supplémentaires utiles (dimensions, types des colonnes...)
- ne font pas de *partial matching* sur les noms de colonnes ^[Dans R de base, si une table `d` contient une colonne `qualif`, `d$qual` retournera cette colonne.]
- affichent un avertissement si on essaie d'accéder à une colonne qui n'existe pas
Pour autant, les tibbles restent compatibles avec les *data frames*. On peut ainsi facilement convertir un *data frame* en tibble avec `as_tibble` :
```{r paged.print=FALSE, warning=FALSE}
as_tibble(mtcars)
```
Si le *data frame* d'origine a des *rownames*, on peut d'abord les convertir en colonnes avec `rownames_to_columns` :
```{r warning=FALSE, paged.print=FALSE}
d <- as_tibble(rownames_to_column(mtcars))
d
```
À l'inverse, on peut à tout moment convertir un tibble en *data frame* avec `as.data.frame` :
```{r paged.print=FALSE}
as.data.frame(d)
```
Là encore, on peut convertir la colonne `rowname` en "vrais" *rownames* avec `column_to_rownames` :
```{r warning=FALSE, paged.print=FALSE}
column_to_rownames(as.data.frame(d))
```
```{block type='rmdnote'}
Les deux fonctions `column_to_rownames` et `rownames_to_column` acceptent un argument supplémentaire `var` qui permet d'indiquer un nom de colonne autre que le nom `rowname` utilisé par défaut pour créer ou identifier la colonne contenant les noms de lignes.
```