Konversi daftar menjadi bingkai data

Saya memiliki daftar data bersarang. Panjangnya adalah 132 dan setiap item adalah daftar panjangnya 20. Apakah ada cara cepat untuk mengubah struktur ini menjadi kerangka data yang memiliki 132 baris dan 20 kolom data?

Berikut ini beberapa contoh data untuk digunakan:

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

Dengan asumsi daftar daftar Anda disebut l:

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

Di atas akan mengkonversi semua kolom karakter ke faktor, untuk menghindari ini, Anda dapat menambahkan parameter ke panggilan data.frame ():

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

Dengan rbind

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

Edit: Sebelumnya versi kembali data.framedari list's bukan vektor (seperti @IanSudbery ditunjukkan dalam komentar).

Anda bisa menggunakan plyrpaket. Misalnya daftar formulir yang bersarang

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

sekarang memiliki panjang 4 dan masing-masing daftar di lberisi daftar panjang lainnya 3. Sekarang Anda dapat menjalankan

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

dan harus mendapatkan hasil yang sama seperti pada jawaban @Marek dan @nico.

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

sapplymengubahnya menjadi sebuah matriks. data.framemengkonversi matriks ke bingkai data.

anggap daftar Anda dipanggil L,

data.frame(Reduce(rbind, L))

Paket ini data.tablememiliki fungsi rbindlistyang merupakan implementasi supercepat dari do.call(rbind, list(...)).

Dapat mengambil daftar lists, data.framesatau data.tables sebagai masukan.

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)

Ini mengembalikan data.tablewarisan dari data.frame.

Jika Anda benar - benar ingin mengonversi kembali ke penggunaan data.frameas.data.frame(DT)

The tibblepaket memiliki fungsi enframe()yang memecahkan masalah ini dengan memaksa bersarang listobjek untuk bersarang tibble( "rapi" frame data) obyek. Berikut adalah contoh singkat dari R untuk Ilmu Data :

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

Karena Anda memiliki beberapa sarang dalam daftar, lAnda dapat menggunakan unlist(recursive = FALSE)untuk menghapus sarang yang tidak perlu untuk mendapatkan hanya satu daftar hierarkis dan kemudian lolos enframe(). Saya gunakan tidyr::unnest()untuk mem-undest output menjadi kerangka data "rapi" tingkat tunggal, yang memiliki dua kolom Anda (satu untuk grup namedan satu untuk pengamatan dengan grup value). Jika Anda ingin kolom yang lebar, Anda bisa menambahkan kolom menggunakan add_column()yang hanya mengulangi urutan nilai 132 kali. Kemudian hanya spread()nilainya.

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>

Bergantung pada struktur daftar Anda, ada beberapa tidyverseopsi yang berfungsi baik dengan daftar panjang yang tidak sama:

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

Anda juga dapat mencampur vektor dan bingkai data:

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

Membentuk ulang2 menghasilkan output yang sama seperti contoh plyr di atas:

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)

hasil:

  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

Jika Anda hampir kehabisan piksel, Anda dapat melakukan ini semua dalam 1 baris dengan pemasangan ulang ().

Metode ini menggunakan tidyversepaket ( purrr ).

Daftar:

x <- as.list(mtcars)

Mengubahnya menjadi bingkai data ( tibblelebih khusus):

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

Memperluas pada jawaban @ Marek: jika Anda ingin menghindari string yang akan berubah menjadi faktor dan efisiensi bukan masalah coba

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

Untuk kasus umum daftar bersarang dalam dengan 3 level atau lebih seperti yang diperoleh dari JSON bersarang:

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

pertimbangkan pendekatan melt()untuk mengonversi daftar bersarang ke format tinggi terlebih dahulu:

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

diikuti dcast()kemudian untuk melebar lagi ke dataset rapi di mana setiap variabel membentuk kolom dan setiap pengamatan membentuk satu baris:

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

Lebih banyak jawaban, bersama dengan waktu dalam jawaban untuk pertanyaan ini: Apa cara paling efisien untuk melemparkan daftar sebagai kerangka data?

Cara tercepat, yang tidak menghasilkan kerangka data dengan daftar daripada vektor untuk kolom tampaknya (dari jawaban 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]])))

Terkadang data Anda mungkin merupakan daftar daftar vektor dengan panjang yang sama.

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

(Vektor dalam juga bisa berupa daftar, tapi saya menyederhanakan untuk membuatnya lebih mudah dibaca).

Kemudian Anda dapat melakukan modifikasi berikut. Ingatlah bahwa Anda dapat membatalkan pendaftaran satu tingkat pada satu waktu:

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

Sekarang gunakan metode favorit Anda yang disebutkan dalam jawaban lain:

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

Inilah yang akhirnya berhasil untuk saya:

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)

Untuk solusi paralel (multicore, multisession, dll) menggunakan purrrkeluarga solusi, gunakan:

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

Dimana ldaftarnya.

Untuk benchmark yang paling efisien, plan()Anda dapat menggunakan:

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

Perintah sederhana berikut ini bekerja untuk saya:

myDf <- as.data.frame(myList)

Referensi ( Jawaban 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"

Tetapi ini akan gagal jika tidak jelas cara mengonversi daftar menjadi bingkai data:

> 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

Catatan : Jawabannya mengarah ke judul pertanyaan dan dapat melompati beberapa detail pertanyaan

Cara pendek (tapi mungkin bukan yang tercepat) untuk melakukan ini adalah dengan menggunakan basis r, karena bingkai data hanyalah daftar vektor dengan panjang yang sama . Dengan demikian konversi antara daftar input Anda dan data.frame 30 x 132 adalah:

df <- data.frame(l)

Dari sana kita dapat memindahkannya ke matriks 132 x 30, dan mengubahnya kembali menjadi kerangka data:

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

Sebagai one-liner:

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

Rownames akan sangat mengganggu untuk dilihat, tetapi Anda selalu bisa mengganti nama dengan

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

Bagaimana kalau menggunakan map_fungsi bersamaan dengan satu forloop? Inilah solusi saya:

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

di mana map_dfrmengkonversi masing-masing elemen daftar ke dalam data.frame dan kemudian persatukan rbindsemuanya.

Dalam kasus Anda, saya kira itu akan:

converted_list <- list_to_df(l)