Convertir une liste de blocs de données dans une trame de données

J'ai un code qui à un endroit se termine avec une liste de trames de données qui j'ai vraiment envie de les convertir vers un seul gros bloc de données.

J'ai eu quelques conseils d'un question précédente qui était en train de faire quelque chose de similaire mais plus complexe.

Voici un exemple de ce que je suis en train de créer avec (c'est extrêmement simplifié pour l'illustration):

listOfDataFrames <- vector(mode = "list", length = 100)

for (i in 1:100) {
    listOfDataFrames[[i]] <- data.frame(a=sample(letters, 500, rep=T),
                             b=rnorm(500), c=rnorm(500))
}

Je suis actuellement en utilisant ceci:

  df <- do.call("rbind", listOfDataFrames)

Voir aussi cette question: stackoverflow.com/questions/2209258/...
Le do.call("rbind", list) idiome est ce que j'ai utilisé avant. Pourquoi avez-vous besoin initial unlist ?
quelqu'un peut-il m'expliquer la différence entre faire.call("rbind", "liste") et rbind(liste) - pourquoi les sorties pas la même chose?
Parce que faire.call() ne retourne pas les arguments un par un, mais utilise une liste de tenir les arguments de la fonction. Voir https://www.stat.berkeley.edu/~s133/Docall.html

InformationsquelleAutor JD Long | 2010-05-17

88

Utilisation bind_rows() de la dplyr package:
```
bind_rows(list_of_dataframes, .id = "column_label")
```
- Solution sympa. .id = "column_label" ajoute la ligne unique des noms sur la liste les noms d'éléments.
- puisque c'est 2018 et dplyr est à la fois rapide et un excellent outil à utiliser, je l'ai changé ce pour la accepté de répondre. Les années, ils volent par!
InformationsquelleAutor joeklieg
181

Une autre option est d'utiliser un plyr fonction:
```
df <- ldply(listOfDataFrames, data.frame)
```
C'est un peu plus lent que l'original:
```
> system.time({ df <- do.call("rbind", listOfDataFrames) })
   user  system elapsed 
   0.25    0.00    0.25 
> system.time({ df2 <- ldply(listOfDataFrames, data.frame) })
   user  system elapsed 
   0.30    0.00    0.29
> identical(df, df2)
[1] TRUE
```
Ma conjecture est que l'utilisation de do.call("rbind", ...) va être le plus rapide de l'approche que vous allez trouver, sauf si vous pouvez faire quelque chose comme (a) utiliser une des matrices à la place d'une base de données.images et (b) préallouer la finale de la matrice, et de confier à elle plutôt que de la développer.

Edit 1:

Basé sur Hadley commentaire, voici la dernière version de rbind.fill de CRAN:
```
> system.time({ df3 <- rbind.fill(listOfDataFrames) })
   user  system elapsed 
   0.24    0.00    0.23 
> identical(df, df3)
[1] TRUE
```
C'est plus facile que rbind, et légèrement plus rapide (ces horaires hold up sur plusieurs pistes). Et aussi loin que je le comprends, la version de plyr sur github est encore plus rapide que cela.
- rbind.remplir la dernière version de plyr est considérablement plus rapide que de le faire.appel et rbind
- intéressant. pour moi rbind.de remplissage a été le plus rapide. Assez étrange, n'.appel / rbind n'a pas de retour identiques VRAI, même si je pouvais ne trouver une différence. Les deux autres étaient égaux, mais plyr a été plus lent.
- I() pourrait remplacer data.frame dans votre ldply appel
- il y a aussi melt.list à remodeler(2)
- do.call(function(...) rbind(..., make.row.names=F), df) est utile si vous ne voulez pas le générés automatiquement unique rownames.
- bind_rows() est plus rapide selon mdm réponse et je pense que c'est le plus simple. Il dispose également de la fonctionnalité d'ajout d'un colonne id
InformationsquelleAutor Shane
106

Dans le but d'exhaustivité, je pensais que la réponse à cette question nécessite une mise à jour. "J'imagine qu'à l'aide de do.call("rbind", ...) va être le plus rapide de l'approche que vous trouverez..." C'est probablement vrai pour le mois de Mai 2010 et après un certain temps, mais dans environ sept 2011 une nouvelle fonction rbindlist a été introduit dans le data.table package de la version 1.8.2, avec une remarque que "Ce ne la même chose que do.call("rbind",l), mais beaucoup plus rapide". Comment beaucoup plus rapide?
```
library(rbenchmark)
benchmark(
  do.call = do.call("rbind", listOfDataFrames),
  plyr_rbind.fill = plyr::rbind.fill(listOfDataFrames), 
  plyr_ldply = plyr::ldply(listOfDataFrames, data.frame),
  data.table_rbindlist = as.data.frame(data.table::rbindlist(listOfDataFrames)),
  replications = 100, order = "relative", 
  columns=c('test','replications', 'elapsed','relative')
  ) 
```
```
                  test replications elapsed relative
4 data.table_rbindlist          100    0.11    1.000
1              do.call          100    9.39   85.364
2      plyr_rbind.fill          100   12.08  109.818
3           plyr_ldply          100   15.14  137.636
```
- Merci beaucoup pour ce, me tirant de mes cheveux parce que mes ensembles de données ont été trop grand pour ldplying un tas de long, fusion des trames de données. De toute façon, j'ai eu une incroyable accélération à l'aide de votre rbindlist suggestion.
- Et une de plus pour l'exhaustivité: dplyr::rbind_all(listOfDataFrames) fera l'affaire).
- est-il équivalent à rbindlist mais que ajoutez les trames de données par colonne ? quelque chose comme un cbindlist ?
- Il n'y est une fonction récente demande: ajouter une fonction cbindlist
- J'ai aussi été tirant sur mes cheveux parce que do.call() avait été en cours d'exécution sur une liste de trames de données pour 18 heures, et n'avait toujours pas fini, je vous remercie!!!
InformationsquelleAutor andrekos

Convertir une liste de blocs de données dans une trame de données

Code:

library(microbenchmark)

dflist <- vector(length=10,mode="list")
for(i in 1:100)
{
  dflist[[i]] <- data.frame(a=runif(n=260),b=runif(n=260),
                            c=rep(LETTERS,10),d=rep(LETTERS,10))
}


mb <- microbenchmark(
plyr::rbind.fill(dflist),
dplyr::bind_rows(dflist),
data.table::rbindlist(dflist),
plyr::ldply(dflist,data.frame),
do.call("rbind",dflist),
times=1000)

ggplot2::autoplot(mb)

Session:

R version 3.3.0 (2016-05-03)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 7 x64 (build 7601) Service Pack 1

> packageVersion("plyr")
[1] ‘1.8.4’
> packageVersion("dplyr")
[1] ‘0.5.0’
> packageVersion("data.table")
[1] ‘1.9.6’

Mise à JOUR:
Réexécutez Le 31-Janv-2018. Exécuté sur le même ordinateur. De nouvelles versions de paquets. Ajouté semences pour les amateurs.

Convertir une liste de blocs de données dans une trame de données

set.seed(21)
library(microbenchmark)

dflist <- vector(length=10,mode="list")
for(i in 1:100)
{
  dflist[[i]] <- data.frame(a=runif(n=260),b=runif(n=260),
                            c=rep(LETTERS,10),d=rep(LETTERS,10))
}


mb <- microbenchmark(
  plyr::rbind.fill(dflist),
  dplyr::bind_rows(dflist),
  data.table::rbindlist(dflist),
  plyr::ldply(dflist,data.frame),
  do.call("rbind",dflist),
  times=1000)

ggplot2::autoplot(mb)+theme_bw()


R version 3.4.0 (2017-04-21)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 7 x64 (build 7601) Service Pack 1

> packageVersion("plyr")
[1] ‘1.8.4’
> packageVersion("dplyr")
[1] ‘0.7.2’
> packageVersion("data.table")
[1] ‘1.10.4’

Mise à JOUR: Réexécutez le 06-Août-2019.

Convertir une liste de blocs de données dans une trame de données

set.seed(21)
library(microbenchmark)

dflist <- vector(length=10,mode="list")
for(i in 1:100)
{
  dflist[[i]] <- data.frame(a=runif(n=260),b=runif(n=260),
                            c=rep(LETTERS,10),d=rep(LETTERS,10))
}


mb <- microbenchmark(
  plyr::rbind.fill(dflist),
  dplyr::bind_rows(dflist),
  data.table::rbindlist(dflist),
  plyr::ldply(dflist,data.frame),
  do.call("rbind",dflist),
  purrr::map_df(dflist,dplyr::bind_rows),
  times=1000)

ggplot2::autoplot(mb)+theme_bw()

R version 3.6.0 (2019-04-26)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Ubuntu 18.04.2 LTS

Matrix products: default
BLAS:   /usr/lib/x86_64-linux-gnu/openblas/libblas.so.3
LAPACK: /usr/lib/x86_64-linux-gnu/libopenblasp-r0.2.20.so

packageVersion("plyr")
packageVersion("dplyr")
packageVersion("data.table")
packageVersion("purrr")

>> packageVersion("plyr")
[1] ‘1.8.4’
>> packageVersion("dplyr")
[1] ‘0.8.3’
>> packageVersion("data.table")
[1] ‘1.12.2’
>> packageVersion("purrr")
[1] ‘0.3.2’

C'est une excellente réponse. J'ai couru la même chose (même OS, même les paquets, les différents randomisation parce que vous n'avez pas set.seed) mais vu certaines différences dans les pires cas de performance. rbindlist avaient effectivement le meilleur du pire des cas ainsi que les meilleures typique dans mes résultats

InformationsquelleAutor rmf

Il est également bind_rows(x, ...) dans dplyr.

> system.time({ df.Base <- do.call("rbind", listOfDataFrames) })
   user  system elapsed 
   0.08    0.00    0.07 
> 
> system.time({ df.dplyr <- as.data.frame(bind_rows(listOfDataFrames)) })
   user  system elapsed 
   0.01    0.00    0.02 
> 
> identical(df.Base, df.dplyr)
[1] TRUE

techniquement parlant, vous n'avez pas besoin de le comme.les données.image - tout ce qui n'en fait exclusivement de données.cadre, par opposition à aussi une table_df (à partir de deplyr)

InformationsquelleAutor TheVTM

13

Voici une autre façon, cela peut être fait (juste de l'ajouter à l'réponses, car reduce est très efficace outil fonctionnel qui est souvent négligé, comme un remplacement pour les boucles. Dans ce cas particulier, aucune de ces sont nettement plus rapides que faire.d'appel)

à l'aide de la base de R:
```
df <- Reduce(rbind, listOfDataFrames)
```
ou, à l'aide de la tidyverse:
```
library(tidyverse) # or, library(dplyr); library(purrr)
df <- listOfDataFrames %>% reduce(bind_rows)
```
InformationsquelleAutor yeedle
11

Comment cela doit être fait dans le tidyverse:
```
df.dplyr.purrr <- listOfDataFrames %>% map_df(bind_rows)
```
- Pourquoi voudriez-vous utiliser map si bind_rows peut prendre une liste de dataframes?
InformationsquelleAutor Nick

Visuel mis à jour pour ceux qui veulent comparer les unes des dernières réponses (j'ai voulu comparer la purrr à dplyr solution). Fondamentalement, j'ai combiné les réponses de @TheVTM et @rmf.

Convertir une liste de blocs de données dans une trame de données

Code:

library(microbenchmark)
library(data.table)
library(tidyverse)

dflist <- vector(length=10,mode="list")
for(i in 1:100)
{
  dflist[[i]] <- data.frame(a=runif(n=260),b=runif(n=260),
                            c=rep(LETTERS,10),d=rep(LETTERS,10))
}


mb <- microbenchmark(
  dplyr::bind_rows(dflist),
  data.table::rbindlist(dflist),
  purrr::map_df(dflist, bind_rows),
  do.call("rbind",dflist),
  times=500)

ggplot2::autoplot(mb)

Session D'Info:

sessionInfo()
R version 3.4.1 (2017-06-30)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 7 x64 (build 7601) Service Pack 1

Les Versions De Package:

> packageVersion("tidyverse")
[1] ‘1.1.1’
> packageVersion("data.table")
[1] ‘1.10.0’

InformationsquelleAutor Nova

7

La seule chose que les solutions avec data.table manquant est l'identifiant de la colonne de savoir à partir de laquelle dataframe dans la liste, les données proviennent de.

Quelque chose comme ceci:
```
df_id <- data.table::rbindlist(listOfDataFrames, idcol = TRUE)
```
La idcol paramètre ajoute une colonne (.id) l'identification de l'origine de la dataframe figurant dans la liste. Le résultat ressemblerait à quelque chose comme ceci:
```
.id a         b           c
1   u   -0.05315128 -1.31975849 
1   b   -1.00404849 1.15257952  
1   y   1.17478229  -0.91043925 
1   q   -1.65488899 0.05846295  
1   c   -1.43730524 0.95245909  
1   b   0.56434313  0.93813197  
```
InformationsquelleAutor f0nzie

Vous devez vous connecter pour publier un commentaire.