Konwertuj listę na ramkę danych

Mam zagnieżdżoną listę danych. Jego długość wynosi 132, a każdy element jest listą o długości 20. Czy istnieje szybki sposób na przekształcenie tej struktury w ramkę danych, która ma 132 wiersze i 20 kolumn danych?

Oto kilka przykładowych danych do pracy:

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

Zakładając, że twoja lista list nazywa się l:

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

Powyższe przekształci wszystkie kolumny znaków w czynniki, aby tego uniknąć, możesz dodać parametr do wywołania data.frame ():

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

Z rbind

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

Edit: Poprzednia wersja powrót data.framez list„s zamiast wektorów (jak @IanSudbery zauważył w komentarzach).

Możesz skorzystać z plyrpakietu. 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 lzawiera kolejną listę o długości 3. Teraz możesz uruchomić

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

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

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

sapplykonwertuje go na macierz. data.framekonwertuje macierz na ramkę danych.

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

data.frame(Reduce(rbind, L))

Pakiet data.tablema funkcję rbindlistsuperszybkiej implementacji do.call(rbind, list(...)).

To może trwać listę lists, data.frameslub 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.tabledziedziczenie z data.frame.

Jeśli naprawdę chcesz przekonwertować z powrotem na data.frame użyjas.data.frame(DT)

tibbleOpakowanie ma funkcję enframe(), która rozwiązuje ten problem przez zmuszanie zagnieżdżonych listobiektów zagnieżdżony tibble( „uporządkowane” ramki danych) obiektów. 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ż na liście znajduje się kilka gniazd l, możesz użyć przycisku unlist(recursive = FALSE)do usunięcia niepotrzebnego zagnieżdżenia, aby uzyskać tylko jedną hierarchiczną listę, a następnie przejść do niej enframe(). Używam tidyr::unnest()do odczekania danych wyjściowych w jednopoziomowej „uporządkowanej” ramce danych, która zawiera dwie kolumny (jedną dla grupy namei jedną dla obserwacji z grupami value). Jeśli chcesz, aby kolumny były szerokie, możesz dodać kolumnę, add_column()która po prostu powtarza kolejność wartości 132 razy. Następnie tylko 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>

W zależności od struktury list istnieje kilka tidyverseopcji, które działają dobrze 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żesz także 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

Reshape2 daje taką samą wydajność jak w powyższym przykładzie 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)

daje:

  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 były niemal z pikseli ty mógł to wszystko zrobić w 1 linii w / przekształcenia ().

Ta metoda używa tidyversepakietu ( mruczenie ).

Lista:

x <- as.list(mtcars)

Przekształcanie go w ramkę danych (a tibbledokładniej):

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

Rozszerzając odpowiedź @ Marka: jeśli chcesz uniknąć zamiany łańcuchów na czynniki, a wydajność nie stanowi problemu, spróbuj

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

Dla ogólnego przypadku głęboko zagnieżdżonych list z 3 lub więcej poziomami, takimi 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ż melt()najpierw podejście do konwersji zagnieżdżonej listy do wysokiego formatu:

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

po dcast()czym następuje przejście do uporządkowanego zestawu danych, w którym każda zmienna tworzy kolumnę, 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

Więcej odpowiedzi wraz z harmonogramem w odpowiedzi na to pytanie: Jaki jest najskuteczniejszy sposób na rzutowanie listy jako ramki danych?

Najszybszym sposobem, który nie tworzy ramki danych z listami zamiast wektorów 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]])))

Czasami twoje dane mogą być 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)) )

(Wektory wewnętrzne 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 wylistować jeden poziom 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

Oto, co w końcu dla mnie zadziałało:

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)

W przypadku rozwiązania równoległego (wielordzeniowego, wielosesyjnego itp.) Używającego purrrrodziny rozwiązań użyj:

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

Gdzie ljest lista.

Aby przetestować najbardziej efektywne plan(), możesz użyć:

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

Dla mnie zadziałało następujące proste polecenie:

myDf <- as.data.frame(myList)

Odniesienie ( odpowiedź 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"

Ale to się nie powiedzie, jeśli nie jest oczywiste, jak przekonwertować listę na ramkę danych:

> 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

Uwaga : odpowiedź dotyczy tytułu pytania i może pomijać niektóre szczegóły pytania

Krótkim (ale być może nie najszybszym) sposobem na zrobienie tego byłoby użycie bazy r, ponieważ ramka danych jest tylko listą wektorów o jednakowej długości . Tak więc konwersja między twoją listą wejściową a 30 x 132 danymi. Ramka byłaby:

df <- data.frame(l)

Stamtąd możemy przetransponować go na matrycę 132 x 30 i przekonwertować z powrotem na ramkę danych:

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

Jako jedna linijka:

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

Nazwy nazw będą dość denerwujące, ale zawsze możesz zmienić ich nazwy

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

Co powiesz na używanie map_funkcji razem z forpętlą? Oto moje rozwiązanie:

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

gdzie map_dfrprzekonwertuj każdy element listy na data.frame, a następnie połącz rbindje całkowicie.

W twoim przypadku myślę, że byłoby to:

converted_list <- list_to_df(l)