Tutoriel Dplyr : Fusionner et joindre des données dans R avec des exemples

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.
  • Visualiser: La dernière étape consiste à visualiser nos données pour vérifier les irrégularités.
Processus d'analyse des données
Processus d'analyse des données

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

Following Il existe quatre types de jointures importants 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 key variable. La fonction recherchera des valeurs identiques dans les deux tableaux et liera les valeurs renvoyées à droite du tableau 1.

Fusionner des données avec R Dplyr

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()

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()

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()

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()

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 ce qui suitwing ensemble de données où nous avons des années ou une liste de produits achetés par le client.

Plusieurs paires de clés dans R

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 suivantwing code 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

Following sont 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 le code suivantwing commande 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.

Exemple de fonction rassembler() dans R

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 suivantwing code:

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 en utilisant following les fonctions:
    • 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.