R-Lista do ramki danych

Z rbind

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

Edit: poprzednia wersja zwraca data.frame z list zamiast wektorów (jak zauważył @IanSudbery w komentarzach).

Możesz użyć pakietu plyr. Na przykład zagnieżdżona lista formularza

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

Ma teraz długość 4, a każda lista w l zawiera kolejną listę o długości 3. Teraz możesz uruchomić

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

I powinien dostać taki sam wynik jak w odpowiedzi @Marek i @nico.

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

sapply przekształca go w matrycę. data.frame konwertuje matrycę na ramkę danych.

Załóżmy, że Twoja lista nazywa się L,

data.frame(Reduce(rbind, L))

Pakiet data.table posiada funkcję rbindlist, która jest superszybką implementacją do.call(rbind, list(...)).

Może mieć listę lists, data.frames lub data.tables jako wejście.

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)

Zwraca data.table dziedziczenie z data.frame.

Jeśli naprawdę. chcesz przekonwertować z powrotem na dane.użycie ramki as.data.frame(DT)

Pakiet tibble posiada funkcję enframe(), która rozwiązuje ten problem poprzez wymuszenie zagnieżdżonych obiektów list do zagnieżdżonych obiektów tibble ("tidy" ramka danych). Oto krótki przykład z R dla 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]>

Ponieważ masz kilka gniazd na liście, l, możesz użyć unlist(recursive = FALSE), aby usunąć niepotrzebne zagnieżdżanie, aby uzyskać tylko jedną hierarchiczną listę, a następnie przejść do enframe(). Używam tidyr::unnest(), aby unnest wyjście do jednego poziomu" tidy " ramki danych, która ma dwie kolumny (jedna dla grupy name i jeden dla obserwacji z grupami value). Jeśli chcesz, aby kolumny były szerokie, możesz dodać kolumnę za pomocą add_column(), która po prostu powtarza kolejność wartości 132 razy. Następnie po prostu spread() wartości.

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>

Reshape2 daje takie samo wyjście jak powyższy przykład plyr:

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)

  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

Jeśli prawie zabrakło pikseli, mógłbyś zrobić to wszystko w jednej linii z funkcją przekształcania ().

Więcej odpowiedzi, wraz z czasem odpowiedzi na to pytanie: Jaki jest najskuteczniejszy sposób tworzenia listy jako ramki danych?

Najszybszy sposób, który nie tworzy ramki danych z listami, a nie wektorami dla kolumn wydaje się być (z odpowiedzi Martina Morgana):

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

Dla ogólnego przypadku głęboko zagnieżdżonych list z 3 lub więcej poziomami jak te uzyskane z zagnieżdżonego JSON:

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

Rozważ podejście melt(), Aby przekonwertować zagnieżdżoną listę na wysoki format:

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

Następnie dcast() Następnie ponownie do szerokiego zbioru danych, gdzie każda zmienna tworzy kolumnę a, a każda obserwacja tworzy wiersz:

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

ODPOWIEDŹ @Marek: jeśli chcesz uniknąć przerobienia ciągów na czynniki, a wydajność nie jest problemem spróbuj

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

Czasami dane mogą być listą list wektorów o tej samej długości.

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

(wewnętrzne wektory mogą być również listami, ale upraszczam, aby ułatwić czytanie).

Następnie możesz wprowadzić następującą modyfikację. Pamiętaj, że możesz nie wyświetlać jednego poziomu na raz:

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

Teraz użyj swojej ulubionej metody wymienionej w innych odpowiedziach:

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

To w końcu mi się udało:

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

W zależności od struktury twoich list istnieje kilka opcji tidyverse, które dobrze działają z listami o nierównej długości:

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

Można również mieszać wektory i ramki danych:

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

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

Ta metoda wykorzystuje pakiet tidyverse (purrr).

Lista:

x <- as.list(mtcars)

Przekształcenie go w ramkę danych (a tibble dokładniej):

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

Test1

Test2

As.data.rama (test2) a b c 1 A b c 2 d e F

Test3

As.data.rama (test3) a b c var2 var3 Row1 A b C
Row2 D e F