Tutoriel Dplyr : Fusionner et joindre des données dans R avec des exemples
Evelyn Clarke
Introduction à l'analyse des données
L'analyse des données peut être divisée en trois parties :
- extraction: Premièrement, nous devons collecter les données provenant de nombreuses sources et les combiner.
- Transformer: Cette étape implique la manipulation des données. Une fois que nous avons consolidé toutes les sources de données, nous pouvons commencer à nettoyer les données.
- Visualisez: La dernière étape consiste à visualiser nos données pour vérifier les irrégularités.
L’un des défis les plus importants auxquels sont confrontés les data scientists est la manipulation des données. Les données ne sont jamais disponibles dans le format souhaité. Les data scientists doivent consacrer au moins la moitié de leur temps au nettoyage et à la manipulation des données. C’est l’une des tâches les plus critiques du poste. Si le processus de manipulation des données n’est pas complet, précis et rigoureux, le modèle ne fonctionnera pas correctement.
R Dplyr
R dispose d'une bibliothèque appelée dplyr pour faciliter la transformation des données. La bibliothèque dplyr est fondamentalement créée autour de quatre fonctions pour manipuler les données et de cinq verbes pour nettoyer les données. Après cela, nous pouvons utiliser la bibliothèque ggplot pour analyser et visualiser les données.
Nous allons apprendre à utiliser la bibliothèque dplyr pour manipuler un Trame de données.
Fusionner des données avec R Dplyr
dplyr fournit un moyen agréable et pratique de combiner des ensembles de données. Nous pouvons disposer de nombreuses sources de données d’entrée et, à un moment donné, nous devons les combiner. Une jointure avec dplyr ajoute des variables à droite de l'ensemble de données d'origine.
Dplyr rejoint
Voici quatre types importants de jointures utilisés dans dplyr pour fusionner deux ensembles de données :
| Fonction | Objectif | Arguments | Plusieurs clés |
|---|---|---|---|
| joint gauche() | Fusionnez deux ensembles de données. Conserver toutes les observations de la table d'origine | données, origine, destination, par = « ID » | origine, destination, par = c("ID", "ID2") |
| right_join() | Fusionnez deux ensembles de données. Conserver toutes les observations de la table de destination | données, origine, destination, par = « ID » | origine, destination, par = c("ID", "ID2") |
| jointure interne() | Fusionnez deux ensembles de données. Exclut toutes les lignes sans correspondance | données, origine, destination, par = « ID » | origine, destination, par = c("ID", "ID2") |
| full_join() | Fusionnez deux ensembles de données. Conserve toutes les observations | données, origine, destination, par = « ID » | origine, destination, par = c("ID", "ID2") |
Nous étudierons tous les types de jointures via un exemple simple.
Tout d’abord, nous construisons deux jeux de données. Le tableau 1 contient deux variables, ID et y, tandis que le tableau 2 rassemble ID et z. Dans chaque situation, nous devons avoir un paire de clés variable. Dans notre cas, l'identification est notre clé variable. La fonction recherchera des valeurs identiques dans les deux tableaux et liera les valeurs renvoyées à droite du tableau 1.
library(dplyr) df_primary <- tribble( ~ID, ~y, "A", 5, "B", 5, "C", 8, "D", 0, "F", 9) df_secondary <- tribble( ~ID, ~z, "A", 30, "B", 21, "C", 22, "D", 25, "E", 29)
Dplyr left_join()
La manière la plus courante de fusionner deux ensembles de données consiste à utiliser la fonction left_join(). Nous pouvons voir sur l'image ci-dessous que la paire de clés correspond parfaitement aux lignes A, B, C et D des deux ensembles de données. Cependant, E et F restent. Comment traiter ces deux observations ? Avec left_join(), nous conserverons toutes les variables dans la table d'origine et ne considérerons pas les variables qui n'ont pas de paire de clés dans la table de destination. Dans notre exemple, la variable E n'existe pas dans le tableau 1. La ligne sera donc supprimée. La variable F provient de la table d'origine ; il sera conservé après le left_join() et retournera NA dans la colonne z. La figure ci-dessous reproduit ce qui se passera avec un left_join().
Exemple de dplyr left_join()
left_join(df_primary, df_secondary, by ='ID')
Sortie :
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA
Dplyr right_join()
La fonction right_join() fonctionne exactement comme left_join(). La seule différence est la ligne supprimée. La valeur E, disponible dans la trame de données de destination, existe dans la nouvelle table et prend la valeur NA pour la colonne y.
Exemple de dplyr right_join()
right_join(df_primary, df_secondary, by = 'ID')
Sortie :
## # A tibble: 5 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 E NA 29
Dplyr inner_join()
Lorsque nous sommes sûrs à 100 % que les deux jeux de données ne correspondent pas, nous pouvons envisager de revenir uniquement lignes existantes dans tous les deux base de données. Cela est possible lorsque nous avons besoin d'un ensemble de données propre ou lorsque nous ne voulons pas imputer les valeurs manquantes avec la moyenne ou la médiane.
Le inner_join() vient en aide. Cette fonction exclut les lignes sans correspondance.
Exemple de dplyr inner_join()
inner_join(df_primary, df_secondary, by ='ID')
Sortie :
## # A tibble: 4 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25
Dplyr full_join()
Enfin, la fonction full_join() conserve toutes les observations et remplace les valeurs manquantes par NA.
Exemple de dplyr full_join()
full_join(df_primary, df_secondary, by = 'ID')
Sortie :
## # A tibble: 6 x 3 ## ID y.x y.y ## <chr> <dbl> <dbl> ## 1 A 5 30 ## 2 B 5 21 ## 3 C 8 22 ## 4 D 0 25 ## 5 F 9 NA ## 6 E NA 29
Plusieurs paires de clés
Enfin et surtout, nous pouvons avoir plusieurs clés dans notre ensemble de données. Considérez l'ensemble de données suivant où nous avons des années ou une liste de produits achetés par le client.
Si nous essayons de fusionner les deux tables, R génère une erreur. Pour remédier à la situation, nous pouvons passer deux variables bi-clés. C'est-à-dire l'ID et l'année qui apparaissent dans les deux ensembles de données. Nous pouvons utiliser le code suivant pour fusionner la table1 et la table 2
df_primary <- tribble(
~ID, ~year, ~items,
"A", 2015,3,
"A", 2016,7,
"A", 2017,6,
"B", 2015,4,
"B", 2016,8,
"B", 2017,7,
"C", 2015,4,
"C", 2016,6,
"C", 2017,6)
df_secondary <- tribble(
~ID, ~year, ~prices,
"A", 2015,9,
"A", 2016,8,
"A", 2017,12,
"B", 2015,13,
"B", 2016,14,
"B", 2017,6,
"C", 2015,15,
"C", 2016,15,
"C", 2017,13)
left_join(df_primary, df_secondary, by = c('ID', 'year'))
Sortie :
## # A tibble: 9 x 4 ## ID year items prices ## <chr> <dbl> <dbl> <dbl> ## 1 A 2015 3 9 ## 2 A 2016 7 8 ## 3 A 2017 6 12 ## 4 B 2015 4 13 ## 5 B 2016 8 14 ## 6 B 2017 7 6 ## 7 C 2015 4 15 ## 8 C 2016 6 15 ## 9 C 2017 6 13
Fonctions de nettoyage des données dans R
Voici les quatre fonctions importantes pour ranger (nettoyer) les données :
| Fonction | Objectif | Arguments |
|---|---|---|
| rassembler() | Transformez les données de large en long | (données, clé, valeur, na.rm = FALSE) |
| propagé() | Transformez les données de longues en larges | (données, clé, valeur) |
| séparé() | Diviser une variable en deux | (données, col, into, sep = "", supprimer = VRAI) |
| unité() | Unité deux variables en une | (données, col, conc, sep = "", supprimer = VRAI) |
Nous utilisons la bibliothèque Tidyr. Cette bibliothèque appartient à la collection de la bibliothèque pour manipuler, nettoyer et visualiser les données. Si nous installons R avec anaconda, la bibliothèque est déjà installée. Nous pouvons trouver la bibliothèque ici, https://anaconda.org/r/r-tidyr.
S'il n'est pas déjà installé, entrez la commande suivante pour installer Tidyr :
install tidyr : install.packages("tidyr")
rassembler()
Les objectifs de la fonction rassembler() sont de transformer les données de large en long.
Syntaxe
gather(data, key, value, na.rm = FALSE) Arguments: -data: The data frame used to reshape the dataset -key: Name of the new column created -value: Select the columns used to fill the key column -na.rm: Remove missing values. FALSE by default
Exemple
Ci-dessous, nous pouvons visualiser le concept de remodelage large à long. Nous souhaitons créer une seule colonne nommée croissance, remplie par les lignes des variables trimestrielles.
library(tidyr)
# Create a messy dataset
messy <- data.frame(
country = c("A", "B", "C"),
q1_2017 = c(0.03, 0.05, 0.01),
q2_2017 = c(0.05, 0.07, 0.02),
q3_2017 = c(0.04, 0.05, 0.01),
q4_2017 = c(0.03, 0.02, 0.04))
messy
Sortie :
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
# Reshape the data tidier <-messy %>% gather(quarter, growth, q1_2017:q4_2017) tidier
Sortie :
## country quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02 ## 7 A q3_2017 0.04 ## 8 B q3_2017 0.05 ## 9 C q3_2017 0.01 ## 10 A q4_2017 0.03 ## 11 B q4_2017 0.02 ## 12 C q4_2017 0.04
Dans la fonction rassembler(), nous créons deux nouvelles variables trimestre et croissance car notre ensemble de données d'origine a une variable de groupe : c'est-à-dire le pays et les paires clé-valeur.
propagé()
La fonction spread() fait le contraire de rassembler.
Syntaxe
spread(data, key, value) arguments: data: The data frame used to reshape the dataset key: Column to reshape long to wide value: Rows used to fill the new column
Exemple
Nous pouvons remodeler l'ensemble de données plus ordonné pour le rendre désordonné avec spread()
# Reshape the data messy_1 <- tidier %>% spread(quarter, growth) messy_1
Sortie :
## country q1_2017 q2_2017 q3_2017 q4_2017 ## 1 A 0.03 0.05 0.04 0.03 ## 2 B 0.05 0.07 0.05 0.02 ## 3 C 0.01 0.02 0.01 0.04
séparé()
La fonction Separate() divise une colonne en deux selon un séparateur. Cette fonction est utile dans certaines situations où la variable est une date. Notre analyse peut nécessiter de se concentrer sur le mois et l'année et nous souhaitons séparer la colonne en deux nouvelles variables.
Syntaxe
separate(data, col, into, sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: The column to split -into: The name of the new variables -sep: Indicates the symbol used that separates the variable, i.e.: "-", "_", "&" -remove: Remove the old column. By default sets to TRUE.
Exemple
Nous pouvons diviser le trimestre de l’année dans l’ensemble de données le plus ordonné en appliquant la fonction Separate().
separate_tidier <-tidier %>%
separate(quarter, c("Qrt", "year"), sep ="_")
head(separate_tidier)
Sortie :
## country Qrt year growth ## 1 A q1 2017 0.03 ## 2 B q1 2017 0.05 ## 3 C q1 2017 0.01 ## 4 A q2 2017 0.05 ## 5 B q2 2017 0.07 ## 6 C q2 2017 0.02
unir()
La fonction unit() concane deux colonnes en une seule.
Syntaxe
unit(data, col, conc ,sep= "", remove = TRUE) arguments: -data: The data frame used to reshape the dataset -col: Name of the new column -conc: Name of the columns to concatenate -sep: Indicates the symbol used that unites the variable, i.e: "-", "_", "&" -remove: Remove the old columns. By default, sets to TRUE
Exemple
Dans l'exemple ci-dessus, nous avons séparé le trimestre de l'année. Et si nous voulons les fusionner. Nous utilisons le code suivant :
unit_tidier <- separate_tidier %>% unite(Quarter, Qrt, year, sep ="_") head(unit_tidier)
Sortie :
## country Quarter growth ## 1 A q1_2017 0.03 ## 2 B q1_2017 0.05 ## 3 C q1_2017 0.01 ## 4 A q2_2017 0.05 ## 5 B q2_2017 0.07 ## 6 C q2_2017 0.02
Résumé
- L'analyse des données peut être divisé en trois parties : Extraction, Transformation et Visualisation.
- R dispose d'une bibliothèque appelée dplyr pour faciliter la transformation des données. La bibliothèque dplyr est fondamentalement créée autour de quatre fonctions pour manipuler les données et de cinq verbes pour nettoyer les données.
- dplyr fournit un moyen agréable et pratique de combiner des ensembles de données. Une jointure avec dplyr ajoute des variables à droite de l'ensemble de données d'origine.
- La beauté de dplyr est qu'il gère quatre types de jointures similaires à SQL:
- joint gauche() – Pour fusionner deux jeux de données et conserver toutes les observations de la table d’origine.
- right_join() – Pour fusionner deux jeux de données et conserver toutes les observations de la table de destination.
- jointure interne() – Pour fusionner deux ensembles de données et exclure toutes les lignes sans correspondance.
- full_join() – Pour fusionner deux jeux de données et conserver toutes les observations.
- À l'aide de la bibliothèque Tidyr, vous pouvez transformer un ensemble de données à l'aide des fonctions suivantes :
- rassembler(): Transformez les données de large en long.
- propagé(): Transformez les données de longues en larges.
- séparé(): Divisez une variable en deux.
- unité(): Unité deux variables en une seule.
