Converter uma lista de quadros de dados em um quadro de dados

Eu tenho um código que em um local termina com uma lista de quadros de dados que eu realmente quero converter em um único quadro de big data.

Eu recebi alguns indicadores de uma pergunta anterior que estava tentando fazer algo semelhante, mas mais complexo.

Aqui está um exemplo do que estou começando (isso é bastante simplificado para ilustração):

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

Atualmente, estou usando isso:

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

Use bind_rows () do pacote dplyr:

bind_rows(list_of_dataframes, .id = "column_label")

Uma outra opção é usar uma função plyr:

df <- ldply(listOfDataFrames, data.frame)

Isso é um pouco mais lento que o 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

Meu palpite é que usar do.call("rbind", ...)será a abordagem mais rápida que você encontrará, a menos que você possa fazer algo como (a) usar matrizes em vez de data.frames e (b) pré-alocar a matriz final e atribuí-la a ela, em vez de aumentá-la. .

Editar 1 :

Com base no comentário de Hadley, aqui está a versão mais recente rbind.filldo CRAN:

> system.time({ df3 <- rbind.fill(listOfDataFrames) })
   user  system elapsed 
   0.24    0.00    0.23 
> identical(df, df3)
[1] TRUE

Isso é mais fácil do que o rbind e marginalmente mais rápido (esses tempos são mantidos em várias execuções). E até onde eu entendo, a versão do plyron github é ainda mais rápida que isso.

Para fins de completude, pensei que as respostas a essa pergunta exigiam uma atualização. "Meu palpite é que o uso do.call("rbind", ...)será a abordagem mais rápida que você encontrará ..." Provavelmente era verdade para maio de 2010 e algum tempo depois, mas por volta de setembro de 2011 uma nova função rbindlistfoi introduzida na data.tableversão 1.8.2 do pacote , com uma observação de que "Isso faz o mesmo que do.call("rbind",l), mas muito mais rápido". Quão rápido?

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

Código:

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)

Sessão:

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’

ATUALIZAÇÃO : Execute novamente 31 de janeiro de 2018. Funcionou no mesmo computador. Novas versões de pacotes. Sementes adicionadas para os amantes de sementes.

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’

ATUALIZAÇÃO : Execute novamente 06-Aug-2019.

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’

Há também bind_rows(x, ...)em 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

Aqui está outra maneira de fazer isso (basta adicioná-lo às respostas, porque reduceé uma ferramenta funcional muito eficaz que muitas vezes é negligenciada como um substituto para os loops. Nesse caso em particular, nenhum deles é significativamente mais rápido que o call.c)

usando a base R:

df <- Reduce(rbind, listOfDataFrames)

ou, usando o tidyverse:

library(tidyverse) # or, library(dplyr); library(purrr)
df <- listOfDataFrames %>% reduce(bind_rows)

Como isso deve ser feito no sentido inverso:

df.dplyr.purrr <- listOfDataFrames %>% map_df(bind_rows)

Um visual atualizado para aqueles que desejam comparar algumas das respostas recentes (eu queria comparar a solução purrr para dplyr). Basicamente, combinei respostas do @TheVTM e do @rmf.

Código:

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)

Informações da sessão:

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

Versões do pacote:

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

A única coisa que data.tablefalta às soluções é a coluna identificadora para saber de qual quadro de dados na lista os dados são provenientes.

Algo assim:

df_id <- data.table::rbindlist(listOfDataFrames, idcol = TRUE)

O idcolparâmetro adiciona uma coluna ( .id) identificando a origem do quadro de dados contida na lista. O resultado seria algo parecido com isto:

.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