Convertir una lista en un marco de datos

Tengo una lista anidada de datos. Su longitud es 132 y cada elemento es una lista de longitud 20. ¿Hay un rápido manera de convertir esta estructura en un marco de datos que tenga 132 filas y 20 columnas de datos?

Aquí hay algunos datos de muestra para trabajar:

l <- replicate(
  132,
  list(sample(letters, 20)),
  simplify = FALSE
)

Asumiendo que su lista de listas se llama l:

df <- data.frame(matrix(unlist(l), nrow=length(l), byrow=T))

Lo anterior convertirá todas las columnas de caracteres en factores, para evitar esto, puede agregar un parámetro a la llamada data.frame ():

df <- data.frame(matrix(unlist(l), nrow=132, byrow=T),stringsAsFactors=FALSE)

Con rbind

do.call(rbind.data.frame, your_list)

Editar: Versión anterior de retorno data.framede list's en lugar de vectores (como @IanSudbery señaló en los comentarios).

Puedes usar el plyrpaquete. Por ejemplo, una lista anidada del formulario

l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
      , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
      , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
      , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
      )

ahora tiene una longitud de 4 y cada lista lcontiene otra lista de la longitud 3. Ahora puede ejecutar

  library (plyr)
  df <- ldply (l, data.frame)

y debería obtener el mismo resultado que en la respuesta @Marek y @nico.

data.frame(t(sapply(mylistlist,c)))

sapplylo convierte en una matriz. data.frameConvierte la matriz en un marco de datos.

asume que tu lista se llama L,

data.frame(Reduce(rbind, L))

El paquete data.tabletiene la función rbindlistque es una implementación súper rápida dedo.call(rbind, list(...)) .

Puede tomar una lista de lists, data.frameso data.tables como entrada.

library(data.table)
ll <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
  , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
  , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
  , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
  )

DT <- rbindlist(ll)

Esto devuelve una data.tableherencia dedata.frame .

Si realmente desea volver a convertir a un data.frame useas.data.frame(DT)

El tibblepaquete tiene una función enframe()que resuelve este problema mediante la coerción de listobjetos anidados a objetos anidados tibble(marco de datos "ordenado"). Aquí hay un breve ejemplo de R para Data Science :

x <- list(
    a = 1:5,
    b = 3:4, 
    c = 5:6
) 

df <- enframe(x)
df
#> # A tibble: 3 × 2
#>    name     value
#>   <chr>    <list>
#>    1     a <int [5]>
#>    2     b <int [2]>
#>    3     c <int [2]>

Como tiene varios nidos en su lista, lpuede usar elunlist(recursive = FALSE) para eliminar el anidamiento innecesario para obtener una sola lista jerárquica y luego pasar a enframe(). Utilizo tidyr::unnest()para descomponer la salida en un marco de datos "ordenado" de un solo nivel, que tiene sus dos columnas (una para el grupo namey otra para las observaciones con los grupos value). Si desea columnas que se amplíen, puede agregar una columna add_column()que simplemente repita el orden de los valores 132 veces. Entonces solo spread()los valores.

library(tidyverse)

l <- replicate(
    132,
    list(sample(letters, 20)),
    simplify = FALSE
)

l_tib <- l %>% 
    unlist(recursive = FALSE) %>% 
    enframe() %>% 
    unnest()
l_tib
#> # A tibble: 2,640 x 2
#>     name value
#>    <int> <chr>
#> 1      1     d
#> 2      1     z
#> 3      1     l
#> 4      1     b
#> 5      1     i
#> 6      1     j
#> 7      1     g
#> 8      1     w
#> 9      1     r
#> 10     1     p
#> # ... with 2,630 more rows

l_tib_spread <- l_tib %>%
    add_column(index = rep(1:20, 132)) %>%
    spread(key = index, value = value)
l_tib_spread
#> # A tibble: 132 x 21
#>     name   `1`   `2`   `3`   `4`   `5`   `6`   `7`   `8`   `9`  `10`  `11`
#> *  <int> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr>
#> 1      1     d     z     l     b     i     j     g     w     r     p     y
#> 2      2     w     s     h     r     i     k     d     u     a     f     j
#> 3      3     r     v     q     s     m     u     j     p     f     a     i
#> 4      4     o     y     x     n     p     i     f     m     h     l     t
#> 5      5     p     w     v     d     k     a     l     r     j     q     n
#> 6      6     i     k     w     o     c     n     m     b     v     e     q
#> 7      7     c     d     m     i     u     o     e     z     v     g     p
#> 8      8     f     s     e     o     p     n     k     x     c     z     h
#> 9      9     d     g     o     h     x     i     c     y     t     f     j
#> 10    10     y     r     f     k     d     o     b     u     i     x     s
#> # ... with 122 more rows, and 9 more variables: `12` <chr>, `13` <chr>,
#> #   `14` <chr>, `15` <chr>, `16` <chr>, `17` <chr>, `18` <chr>,
#> #   `19` <chr>, `20` <chr>

Dependiendo de la estructura de sus listas, hay algunas tidyverseopciones que funcionan bien con listas de longitud desigual:

l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
        , b = list(var.1 = 4, var.2 = 5)
        , c = list(var.1 = 7, var.3 = 9)
        , d = list(var.1 = 10, var.2 = 11, var.3 = NA))

df <- dplyr::bind_rows(l)
df <- purrr::map_df(l, dplyr::bind_rows)
df <- purrr::map_df(l, ~.x)

# all create the same data frame:
# A tibble: 4 x 3
  var.1 var.2 var.3
  <dbl> <dbl> <dbl>
1     1     2     3
2     4     5    NA
3     7    NA     9
4    10    11    NA

También puede mezclar vectores y marcos de datos:

library(dplyr)
bind_rows(
  list(a = 1, b = 2),
  data_frame(a = 3:4, b = 5:6),
  c(a = 7)
)

# A tibble: 4 x 2
      a     b
  <dbl> <dbl>
1     1     2
2     3     5
3     4     6
4     7    NA

Reshape2 produce el mismo resultado que el ejemplo de plyr anterior:

library(reshape2)
l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
          , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
          , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
          , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
)
l <- melt(l)
dcast(l, L1 ~ L2)

rendimientos:

  L1 var.1 var.2 var.3
1  a     1     2     3
2  b     4     5     6
3  c     7     8     9
4  d    10    11    12

Si estaba casi sin píxeles, podría hacer esto todo en 1 línea con recast ().

Este método utiliza un tidyversepaquete ( ronroneo ).

La lista:

x <- as.list(mtcars)

Convirtiéndolo en un marco de datos ( tibblemás específicamente):

library(purrr)
map_df(x, ~.x)

Ampliando la respuesta de @ Marek: si desea evitar que las cadenas se conviertan en factores y la eficiencia no es una preocupación, intente

do.call(rbind, lapply(your_list, data.frame, stringsAsFactors=FALSE))

Para el caso general de listas profundamente anidadas con 3 o más niveles como los obtenidos de un JSON anidado:

{
"2015": {
  "spain": {"population": 43, "GNP": 9},
  "sweden": {"population": 7, "GNP": 6}},
"2016": {
  "spain": {"population": 45, "GNP": 10},
  "sweden": {"population": 9, "GNP": 8}}
}

considere el enfoque de melt()convertir la lista anidada a un formato alto primero:

myjson <- jsonlite:fromJSON(file("test.json"))
tall <- reshape2::melt(myjson)[, c("L1", "L2", "L3", "value")]
    L1     L2         L3 value
1 2015  spain population    43
2 2015  spain        GNP     9
3 2015 sweden population     7
4 2015 sweden        GNP     6
5 2016  spain population    45
6 2016  spain        GNP    10
7 2016 sweden population     9
8 2016 sweden        GNP     8

seguido por dcast()entonces para ampliarse nuevamente en un conjunto de datos ordenado donde cada variable forma una columna y cada observación forma una fila:

wide <- reshape2::dcast(tall, L1+L2~L3) 
# left side of the formula defines the rows/observations and the 
# right side defines the variables/measurements
    L1     L2 GNP population
1 2015  spain   9         43
2 2015 sweden   6          7
3 2016  spain  10         45
4 2016 sweden   8          9

Más respuestas, junto con tiempos en la respuesta a esta pregunta: ¿Cuál es la forma más eficiente de emitir una lista como un marco de datos?

La forma más rápida, que no produce un marco de datos con listas en lugar de vectores para columnas parece ser (de la respuesta de Martin Morgan):

l <- list(list(col1="a",col2=1),list(col1="b",col2=2))
f = function(x) function(i) unlist(lapply(x, `[[`, i), use.names=FALSE)
as.data.frame(Map(f(l), names(l[[1]])))

Algunas veces sus datos pueden ser una lista de listas de vectores de la misma longitud.

lolov = list(list(c(1,2,3),c(4,5,6)), list(c(7,8,9),c(10,11,12),c(13,14,15)) )

(Los vectores internos también podrían ser listas, pero estoy simplificando para que sea más fácil de leer).

Entonces puedes hacer la siguiente modificación. Recuerde que puede anular la lista de un nivel a la vez:

lov = unlist(lolov, recursive = FALSE )
> lov
[[1]]
[1] 1 2 3

[[2]]
[1] 4 5 6

[[3]]
[1] 7 8 9

[[4]]
[1] 10 11 12

[[5]]
[1] 13 14 15

Ahora use su método favorito mencionado en las otras respuestas:

library(plyr)
>ldply(lov)
  V1 V2 V3
1  1  2  3
2  4  5  6
3  7  8  9
4 10 11 12
5 13 14 15

Esto es lo que finalmente funcionó para mí:

do.call("rbind", lapply(S1, as.data.frame))

l <- replicate(10,list(sample(letters, 20)))
a <-lapply(l[1:10],data.frame)
do.call("cbind", a)

Para una solución en paralelo (multinúcleo, multisesión, etc.) que utiliza una purrrfamilia de soluciones, use:

library (furrr)
plan(multisession) # see below to see which other plan() is the more efficient
myTibble <- future_map_dfc(l, ~.x)

Donde lesta la lista

Para comparar el más eficiente plan()que puede usar:

library(tictoc)
plan(sequential) # reference time
# plan(multisession) # benchamark plan() goes here. See ?plan().
tic()
myTibble <- future_map_dfc(l, ~.x)
toc()

El siguiente comando simple funcionó para mí:

myDf <- as.data.frame(myList)

Referencia ( respuesta de Quora )

> myList <- list(a = c(1, 2, 3), b = c(4, 5, 6))
> myList
$a
[1] 1 2 3

$b
[1] 4 5 6

> myDf <- as.data.frame(myList)
  a b
1 1 4
2 2 5
3 3 6
> class(myDf)
[1] "data.frame"

Pero esto fallará si no es obvio cómo convertir la lista a un marco de datos:

> myList <- list(a = c(1, 2, 3), b = c(4, 5, 6, 7))
> myDf <- as.data.frame(myList)
Error in (function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE,  : 
  arguments imply differing number of rows: 3, 4

Nota : La respuesta es hacia el título de la pregunta y puede omitir algunos detalles de la pregunta.

Una forma corta (pero quizás no la más rápida) de hacerlo sería utilizar la base r, ya que un marco de datos es solo una lista de vectores de igual longitud . Por lo tanto, la conversión entre su lista de entrada y un marco de datos de 30 x 132 sería:

df <- data.frame(l)

Desde allí, podemos transponerlo a una matriz de 132 x 30 y convertirlo nuevamente en un marco de datos:

new_df <- data.frame(t(df))

Como una línea:

new_df <- data.frame(t(data.frame(l)))

Los nombres de las filas serán bastante molestos de ver, pero siempre puede cambiar el nombre de aquellos con

rownames(new_df) <- 1:nrow(new_df)

¿Qué hay de usar map_ función junto con un forbucle? Aquí está mi solución:

list_to_df <- function(list_to_convert) {
  tmp_data_frame <- data.frame()
  for (i in 1:length(list_to_convert)) {
    tmp <- map_dfr(list_to_convert[[i]], data.frame)
    tmp_data_frame <- rbind(tmp_data_frame, tmp)
  }
  print(tmp_data_frame)
}

donde map_dfrconvertir cada elemento de la lista en un data.frame y luego rbindunirlos por completo.

En su caso, supongo que sería:

converted_list <- list_to_df(l)