Fusionner simultanément plusieurs data.frames dans une liste

J'ai une liste de nombreux data.frames que je veux fusionner. Le problème ici est que chaque data.frame diffère en termes de nombre de lignes et de colonnes, mais ils partagent tous les variables clés (que j'ai appelées "var1"et "var2"dans le code ci-dessous). Si les data.frames étaient identiques en termes de colonnes, je pourrais simplement rbind, pour lequel ryrind.fill de plyr ferait le travail, mais ce n'est pas le cas avec ces données.

Parce que la mergecommande ne fonctionne que sur 2 data.frames, je me suis tourné vers Internet pour des idées. J'ai obtenu celui-ci d' ici , qui fonctionnait parfaitement dans R 2.7.2, ce que j'avais à l'époque:

merge.rec <- function(.list, ...){
    if(length(.list)==1) return(.list[[1]])
    Recall(c(list(merge(.list[[1]], .list[[2]], ...)), .list[-(1:2)]), ...)
}

Et j'appellerais la fonction comme ceci:

df <- merge.rec(my.list, by.x = c("var1", "var2"), 
                by.y = c("var1", "var2"), all = T, suffixes=c("", ""))

Mais dans toute version R après 2.7.2, y compris 2.11 et 2.12, ce code échoue avec l'erreur suivante:

Error in match.names(clabs, names(xi)) : 
  names do not match previous names

(Par ailleurs, je vois d'autres références à cette erreur ailleurs sans résolution).

Est-ce qu'il y a un moyen de résoudre ceci?

Une autre question portait précisément comment effectuer plusieurs jointures avec gauche dplyr dans R . La question a été marquée comme un double de celle-ci, je réponds donc ici en utilisant les 3 exemples de trames de données ci-dessous:

x <- data.frame(i = c("a","b","c"), j = 1:3, stringsAsFactors=FALSE)
y <- data.frame(i = c("b","c","d"), k = 4:6, stringsAsFactors=FALSE)
z <- data.frame(i = c("c","d","a"), l = 7:9, stringsAsFactors=FALSE)

Mise à jour de juin 2018 : j'ai divisé la réponse en trois sections représentant trois façons différentes d'effectuer la fusion. Vous voudrez probablement utiliser le purrrchemin si vous utilisez déjà les packages tidyverse . À des fins de comparaison ci-dessous, vous trouverez une version de base R utilisant le même ensemble de données exemple.

1) Rejoignez-les avec reducedu purrrpackage:

Le purrrpackage fournit une reducefonction qui a une syntaxe concise:

library(tidyverse)
list(x, y, z) %>% reduce(left_join, by = "i")
#  A tibble: 3 x 4
#  i       j     k     l
#  <chr> <int> <int> <int>
# 1 a      1    NA     9
# 2 b      2     4    NA
# 3 c      3     5     7

Vous pouvez également effectuer d'autres jointures, telles qu'un full_joinou inner_join:

list(x, y, z) %>% reduce(full_join, by = "i")
# A tibble: 4 x 4
# i       j     k     l
# <chr> <int> <int> <int>
# 1 a     1     NA     9
# 2 b     2     4      NA
# 3 c     3     5      7
# 4 d     NA    6      8

list(x, y, z) %>% reduce(inner_join, by = "i")
# A tibble: 1 x 4
# i       j     k     l
# <chr> <int> <int> <int>
# 1 c     3     5     7

2) dplyr::left_join()avec base R Reduce():

list(x,y,z) %>%
    Reduce(function(dtf1,dtf2) left_join(dtf1,dtf2,by="i"), .)

#   i j  k  l
# 1 a 1 NA  9
# 2 b 2  4 NA
# 3 c 3  5  7

3) Base R merge()avec base R Reduce():

Et à des fins de comparaison, voici une version de base R de la jointure gauche

 Reduce(function(dtf1, dtf2) merge(dtf1, dtf2, by = "i", all.x = TRUE),
        list(x,y,z))
#   i j  k  l
# 1 a 1 NA  9
# 2 b 2  4 NA
# 3 c 3  5  7

Réduire rend cela assez simple:

merged.data.frame = Reduce(function(...) merge(..., all=T), list.of.data.frames)

Voici un exemple complet utilisant des données fictives:

set.seed(1)
list.of.data.frames = list(data.frame(x=1:10, a=1:10), data.frame(x=5:14, b=11:20), data.frame(x=sample(20, 10), y=runif(10)))
merged.data.frame = Reduce(function(...) merge(..., all=T), list.of.data.frames)
tail(merged.data.frame)
#    x  a  b         y
#12 12 NA 18        NA
#13 13 NA 19        NA
#14 14 NA 20 0.4976992
#15 15 NA NA 0.7176185
#16 16 NA NA 0.3841037
#17 19 NA NA 0.3800352

Et voici un exemple utilisant ces données pour répliquer my.list:

merged.data.frame = Reduce(function(...) merge(..., by=match.by, all=T), my.list)
merged.data.frame[, 1:12]

#  matchname party st district chamber senate1993 name.x v2.x v3.x v4.x senate1994 name.y
#1   ALGIERE   200 RI      026       S         NA   <NA>   NA   NA   NA         NA   <NA>
#2     ALVES   100 RI      019       S         NA   <NA>   NA   NA   NA         NA   <NA>
#3    BADEAU   100 RI      032       S         NA   <NA>   NA   NA   NA         NA   <NA>

Remarque: il semble que ce soit un bogue merge. Le problème est qu'il n'y a aucune vérification que l'ajout des suffixes (pour gérer les noms non correspondants qui se chevauchent) les rend réellement uniques. À un certain moment, il utilise [.data.framece qui fait make.unique les noms, provoquant l' rbindéchec de.

# first merge will end up with 'name.x' & 'name.y'
merge(my.list[[1]], my.list[[2]], by=match.by, all=T)
# [1] matchname    party        st           district     chamber      senate1993   name.x      
# [8] votes.year.x senate1994   name.y       votes.year.y
#<0 rows> (or 0-length row.names)
# as there is no clash, we retain 'name.x' & 'name.y' and get 'name' again
merge(merge(my.list[[1]], my.list[[2]], by=match.by, all=T), my.list[[3]], by=match.by, all=T)
# [1] matchname    party        st           district     chamber      senate1993   name.x      
# [8] votes.year.x senate1994   name.y       votes.year.y senate1995   name         votes.year  
#<0 rows> (or 0-length row.names)
# the next merge will fail as 'name' will get renamed to a pre-existing field.

Le moyen le plus simple de corriger est de ne pas laisser le champ renommer les champs en double (dont il y en a beaucoup ici) jusqu'à merge. Par exemple:

my.list2 = Map(function(x, i) setNames(x, ifelse(names(x) %in% match.by,
      names(x), sprintf('%s.%d', names(x), i))), my.list, seq_along(my.list))

Le merge/ Reducefonctionnera alors correctement.

Vous pouvez le faire en utilisant merge_alldans le reshapepackage. Vous pouvez passer des paramètres à l' mergeaide de l' ...argument

reshape::merge_all(list_of_dataframes, ...)

Voici une excellente ressource sur différentes méthodes de fusion de trames de données .

Vous pouvez utiliser la récursivité pour ce faire. Je n'ai pas vérifié les éléments suivants, mais cela devrait vous donner la bonne idée:

MergeListOfDf = function( data , ... )
{
    if ( length( data ) == 2 ) 
    {
        return( merge( data[[ 1 ]] , data[[ 2 ]] , ... ) )
    }    
    return( merge( MergeListOfDf( data[ -1 ] , ... ) , data[[ 1 ]] , ... ) )
}

Je vais réutiliser l'exemple de données de @PaulRougieux

x <- data_frame(i = c("a","b","c"), j = 1:3)
y <- data_frame(i = c("b","c","d"), k = 4:6)
z <- data_frame(i = c("c","d","a"), l = 7:9)

Voici une solution courte et douce en utilisant purrrettidyr

library(tidyverse)

 list(x, y, z) %>% 
  map_df(gather, key=key, value=value, -i) %>% 
  spread(key, value)

La fonction eatde mon package safejoin a une telle fonctionnalité, si vous lui donnez une liste de data.frames en tant que deuxième entrée, elles les rejoindront récursivement à la première entrée.

Emprunter et étendre les données de la réponse acceptée:

x <- data_frame(i = c("a","b","c"), j = 1:3)
y <- data_frame(i = c("b","c","d"), k = 4:6)
z <- data_frame(i = c("c","d","a"), l = 7:9)
z2 <- data_frame(i = c("a","b","c"), l = rep(100L,3),l2 = rep(100L,3)) # for later

# devtools::install_github("moodymudskipper/safejoin")
library(safejoin)
eat(x, list(y,z), .by = "i")
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

Nous n'avons pas à prendre toutes les colonnes, nous pouvons utiliser certains assistants de tidyselect et choisir (comme nous partons de .xtoutes les .xcolonnes sont conservées):

eat(x, list(y,z), starts_with("l") ,.by = "i")
# # A tibble: 3 x 3
#   i         j     l
#   <chr> <int> <int>
# 1 a         1     9
# 2 b         2    NA
# 3 c         3     7

ou supprimez ceux spécifiques:

eat(x, list(y,z), -starts_with("l") ,.by = "i")
# # A tibble: 3 x 3
#   i         j     k
#   <chr> <int> <int>
# 1 a         1    NA
# 2 b         2     4
# 3 c         3     5

Si la liste est nommée, les noms seront utilisés comme préfixes:

eat(x, dplyr::lst(y,z), .by = "i")
# # A tibble: 3 x 4
#   i         j   y_k   z_l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

S'il y a des conflits de colonnes, l' .conflictargument vous permet de le résoudre, par exemple en prenant le premier / second, en les ajoutant, en les fusionnant ou en les imbriquant.

garder en premier:

eat(x, list(y, z, z2), .by = "i", .conflict = ~.x)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <int>
# 1 a         1    NA     9
# 2 b         2     4    NA
# 3 c         3     5     7

garder en dernier:

eat(x, list(y, z, z2), .by = "i", .conflict = ~.y)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA   100
# 2 b         2     4   100
# 3 c         3     5   100

ajouter:

eat(x, list(y, z, z2), .by = "i", .conflict = `+`)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA   109
# 2 b         2     4    NA
# 3 c         3     5   107

se fondre:

eat(x, list(y, z, z2), .by = "i", .conflict = dplyr::coalesce)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <int> <dbl>
# 1 a         1    NA     9
# 2 b         2     4   100
# 3 c         3     5     7

nid:

eat(x, list(y, z, z2), .by = "i", .conflict = ~tibble(first=.x, second=.y))
# # A tibble: 3 x 4
#   i         j     k l$first $second
#   <chr> <int> <int>   <int>   <int>
# 1 a         1    NA       9     100
# 2 b         2     4      NA     100
# 3 c         3     5       7     100

NAles valeurs peuvent être remplacées en utilisant l' .fillargument.

eat(x, list(y, z), .by = "i", .fill = 0)
# # A tibble: 3 x 4
#   i         j     k     l
#   <chr> <int> <dbl> <dbl>
# 1 a         1     0     9
# 2 b         2     4     0
# 3 c         3     5     7

Par défaut, c'est une amélioration, left_joinmais toutes les jointures dplyr sont prises en charge via l' .modeargument, les jointures floues sont également prises en charge via l' match_fun argument (il est enroulé autour du package fuzzyjoin) ou en donnant une formule telle que ~ X("var1") > Y("var2") & X("var3") < Y("var4")l' byargument.

J'avais une liste de trames de données sans colonne d'ID commune.
Il me manquait des données sur de nombreux DFS. Il y avait des valeurs nulles. Les trames de données ont été produites à l'aide de la fonction de table. La fonction Réduire, Fusionner, rbind, rbind.fill et leurs semblables ne pouvaient pas m'aider à atteindre mon objectif. Mon objectif était de produire une trame de données fusionnée compréhensible, sans rapport avec les données manquantes et la colonne d'identification commune.

Par conséquent, j'ai fait la fonction suivante. Peut-être que cette fonction peut aider quelqu'un.

##########################################################
####             Dependencies                        #####
##########################################################

# Depends on Base R only

##########################################################
####             Example DF                          #####
##########################################################

# Example df
ex_df           <- cbind(c( seq(1, 10, 1), rep("NA", 0), seq(1,10, 1) ), 
                         c( seq(1, 7, 1),  rep("NA", 3), seq(1, 12, 1) ), 
                         c( seq(1, 3, 1),  rep("NA", 7), seq(1, 5, 1), rep("NA", 5) ))

# Making colnames and rownames
colnames(ex_df) <- 1:dim(ex_df)[2]
rownames(ex_df) <- 1:dim(ex_df)[1]

# Making an unequal list of dfs, 
# without a common id column
list_of_df      <- apply(ex_df=="NA", 2, ( table) )

il suit la fonction

##########################################################
####             The function                        #####
##########################################################


# The function to rbind it
rbind_null_df_lists <- function ( list_of_dfs ) {
  length_df     <- do.call(rbind, (lapply( list_of_dfs, function(x) length(x))))
  max_no        <- max(length_df[,1])
  max_df        <- length_df[max(length_df),]
  name_df       <- names(length_df[length_df== max_no,][1])
  names_list    <- names(list_of_dfs[ name_df][[1]])

  df_dfs <- list()
  for (i in 1:max_no ) {

    df_dfs[[i]]            <- do.call(rbind, lapply(1:length(list_of_dfs), function(x) list_of_dfs[[x]][i]))

  }

  df_cbind               <- do.call( cbind, df_dfs )
  rownames( df_cbind )   <- rownames (length_df)
  colnames( df_cbind )   <- names_list

  df_cbind

}

Exécuter l'exemple

##########################################################
####             Running the example                 #####
##########################################################

rbind_null_df_lists ( list_of_df )

Lorsque vous avez une liste de dfs et qu'une colonne contient l '"ID", mais dans certaines listes, certains ID sont manquants, vous pouvez utiliser cette version de Reduce / Merge afin de joindre plusieurs Dfs d'ID de ligne ou d'étiquettes manquantes:

Reduce(function(x, y) merge(x=x, y=y, by="V1", all.x=T, all.y=T), list_of_dfs)

Voici un wrapper générique qui peut être utilisé pour convertir une fonction binaire en fonction multi-paramètres. L'avantage de cette solution est qu'elle est très générique et peut être appliquée à toutes les fonctions binaires. Vous n'avez qu'à le faire une fois et vous pouvez l'appliquer n'importe où.

Pour faire une démonstration de l'idée, j'utilise une récursivité simple à implémenter. Il peut bien sûr être implémenté de manière plus élégante qui bénéficie du bon support de R pour le paradigme fonctionnel.

fold_left <- function(f) {
return(function(...) {
    args <- list(...)
    return(function(...){
    iter <- function(result,rest) {
        if (length(rest) == 0) {
            return(result)
        } else {
            return(iter(f(result, rest[[1]], ...), rest[-1]))
        }
    }
    return(iter(args[[1]], args[-1]))
    })
})}

Ensuite, vous pouvez simplement envelopper toutes les fonctions binaires avec lui et appeler avec les paramètres de position (généralement data.frames) dans les premières parenthèses et les paramètres nommés dans les secondes parenthèses (comme by =ou suffix =). Si aucun paramètre nommé, laissez les deuxièmes parenthèses vides.

merge_all <- fold_left(merge)
merge_all(df1, df2, df3, df4, df5)(by.x = c("var1", "var2"), by.y = c("var1", "var2"))

left_join_all <- fold_left(left_join)
left_join_all(df1, df2, df3, df4, df5)(c("var1", "var2"))
left_join_all(df1, df2, df3, df4, df5)()