Comment joindre (fusionner) des cadres de données (intérieur, extérieur, gauche, droite) ?

Question

Étant donné deux cadres de données :

df1 = data.frame(CustomerId = c(1:6), Product = c(rep("Toaster", 3), rep("Radio", 3)))
df2 = data.frame(CustomerId = c(2, 4, 6), State = c(rep("Alabama", 2), rep("Ohio", 1)))

df1
#  CustomerId Product
#           1 Toaster
#           2 Toaster
#           3 Toaster
#           4   Radio
#           5   Radio
#           6   Radio

df2
#  CustomerId   State
#           2 Alabama
#           4 Alabama
#           6    Ohio

Comment puis-je faire du style base de données, c'est-à-dire, style sql, jointures ? C'est-à-dire, comment puis-je obtenir :

• Un jointure intérieure de df1 y df2 :
  Renvoie uniquement les lignes dans lesquelles la table de gauche a des clés correspondantes dans la table de droite.
• Un jointure extérieure de df1 y df2 :
  Renvoie toutes les lignes des deux tables, en joignant les enregistrements de gauche qui ont des clés correspondantes dans la table de droite.
• A jointure externe gauche (ou simplement jointure gauche) de df1 y df2
  Renvoie toutes les lignes de la table de gauche, et toutes les lignes avec des clés correspondantes de la table de droite.
• A jointure externe droite de df1 y df2
  Renvoie toutes les lignes de la table de droite, et toutes les lignes avec des clés correspondantes de la table de gauche.

---

Un crédit supplémentaire :

Comment puis-je faire une instruction de sélection de style SQL ?

Answer 1

En utilisant le merge et ses paramètres facultatifs :

Jointure intérieure : merge(df1, df2) fonctionnera pour ces exemples car R joint automatiquement les cadres par des noms de variables communs, mais vous voudrez très probablement spécifier merge(df1, df2, by = "CustomerId") pour vous assurer que vous ne faites correspondre que les champs que vous souhaitez. Vous pouvez également utiliser la fonction by.x y by.y si les variables correspondantes ont des noms différents dans les différentes trames de données.

Jointure extérieure : merge(x = df1, y = df2, by = "CustomerId", all = TRUE)

Extérieur gauche : merge(x = df1, y = df2, by = "CustomerId", all.x = TRUE)

Extérieur droit : merge(x = df1, y = df2, by = "CustomerId", all.y = TRUE)

Croisez les joints : merge(x = df1, y = df2, by = NULL)

Tout comme pour la jointure interne, vous voudrez probablement transmettre explicitement "CustomerId" à R comme variable de correspondance. Je pense qu'il est presque toujours préférable d'indiquer explicitement les identifiants sur lesquels vous voulez fusionner ; c'est plus sûr si les data.frames d'entrée changent de manière inattendue et plus facile à lire par la suite.

Vous pouvez fusionner sur plusieurs colonnes en donnant by un vecteur, par exemple, by = c("CustomerId", "OrderId") .

Si les noms des colonnes à fusionner ne sont pas les mêmes, vous pouvez spécifier, par exemple, by.x = "CustomerId_in_df1", by.y = "CustomerId_in_df2" donde CustomerId_in_df1 est le nom de la colonne dans le premier cadre de données et CustomerId_in_df2 est le nom de la colonne dans le deuxième cadre de données. (Il peut également s'agir de vecteurs si vous avez besoin de fusionner sur plusieurs colonnes).

Answer 2

Je vous recommande de vérifier Le paquet sqldf de Gabor Grothendieck qui vous permet d'exprimer ces opérations en SQL.

library(sqldf)

## inner join
df3 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              JOIN df2 USING(CustomerID)")

## left join (substitute 'right' for right join)
df4 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              LEFT JOIN df2 USING(CustomerID)")

Je trouve la syntaxe SQL plus simple et plus naturelle que son équivalent R (mais cela reflète peut-être mon penchant pour les SGBDR).

Ver GitHub sqldf de Gabor pour plus d'informations sur les jointures.

Answer 3

Il y a le table.de.données pour une jointure interne, qui est très efficace en termes de temps et de mémoire (et nécessaire pour certains cadres de données plus grands) :

library(data.table)

dt1 <- data.table(df1, key = "CustomerId") 
dt2 <- data.table(df2, key = "CustomerId")

joined.dt1.dt.2 <- dt1[dt2]

merge fonctionne également sur data.tables (car il est générique et appelle merge.data.table )

merge(dt1, dt2)

data.table documenté sur stackoverflow :
Comment effectuer une opération de fusion data.table ?
Traduction des jointures SQL sur les clés étrangères en syntaxe R data.table
Alternatives efficaces à la fusion pour les cadres de données plus grands R
Comment faire une jointure extérieure gauche de base avec data.table en R ?

Une autre option encore est le join qui se trouve dans le plyr paquet

library(plyr)

join(df1, df2,
     type = "inner")

#   CustomerId Product   State
# 1          2 Toaster Alabama
# 2          4   Radio Alabama
# 3          6   Radio    Ohio

Options pour type : inner , left , right , full .

De ?join : Contrairement à merge , [ join ] préserve l'ordre de x quel que soit le type de jointure utilisé.

Answer 4

Vous pouvez aussi faire des jointures en utilisant l'impressionnante méthode de Hadley Wickham. dplyr paquet.

library(dplyr)

#make sure that CustomerId cols are both type numeric
#they ARE not using the provided code in question and dplyr will complain
df1$CustomerId <- as.numeric(df1$CustomerId)
df2$CustomerId <- as.numeric(df2$CustomerId)

Mutations de jointures : ajouter des colonnes à df1 en utilisant des correspondances dans df2

#inner
inner_join(df1, df2)

#left outer
left_join(df1, df2)

#right outer
right_join(df1, df2)

#alternate right outer
left_join(df2, df1)

#full join
full_join(df1, df2)

Filtrage des jointures : filtrer les lignes dans df1, ne pas modifier les colonnes

semi_join(df1, df2) #keep only observations in df1 that match in df2.
anti_join(df1, df2) #drops all observations in df1 that match in df2.

Answer 5

Vous trouverez de bons exemples de cette démarche sur le site de la R Wiki . Je vais en voler quelques-uns ici :

Méthode de fusion

Puisque vos clés sont nommées de la même façon, le moyen le plus court de faire une jointure interne est merge() :

merge(df1,df2)

une jointure interne complète (tous les enregistrements des deux tables) peut être créée avec le mot clé "all" :

merge(df1,df2, all=TRUE)

une jointure externe gauche de df1 et df2 :

merge(df1,df2, all.x=TRUE)

une jointure externe droite de df1 et df2 :

merge(df1,df2, all.y=TRUE)

vous pouvez les retourner, les gifler et les frotter pour obtenir les deux autres joints extérieurs dont vous parliez :)

Méthode de l'indice

Une jointure externe gauche avec df1 à gauche en utilisant la méthode des indices serait la suivante :

df1[,"State"]<-df2[df1[ ,"Product"], "State"]

L'autre combinaison de jointures externes peut être créée en modifiant l'exemple de l'indice de jointure externe gauche. (oui, je sais que c'est l'équivalent de dire "je laisse cela comme un exercice pour le lecteur...")