Convertir une liste en un bloc de données

J'ai une liste imbriquée de données. Sa longueur est de 132 et chaque élément est une liste de longueur 20. Existe-t-il un moyen rapide de convertir cette structure en un bloc de données qui comprend 132 lignes et 20 colonnes de données?

Voici quelques exemples de données avec lesquelles travailler:

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

En supposant que votre liste de listes s'appelle l:

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

Ce qui précède convertira toutes les colonnes de caractères en facteurs, pour éviter cela, vous pouvez ajouter un paramètre à l'appel data.frame ():

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

Avec rbind

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

Edit: retour data.framede listla version précédente de 's au lieu de vecteurs (comme l'a souligné @IanSudbery dans les commentaires).

Vous pouvez utiliser le plyrpackage. Par exemple, une liste imbriquée du formulaire

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

a maintenant une longueur de 4 et chaque liste lcontient une autre liste de la longueur 3. Maintenant, vous pouvez exécuter

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

et devrait obtenir le même résultat que dans la réponse @Marek et @nico.

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

sapplyle convertit en matrice. data.frameconvertit la matrice en une trame de données.

supposons que votre liste est appelée L,

data.frame(Reduce(rbind, L))

Le paquet data.tablea la fonction rbindlistqui est une implémentation ultra-rapide de do.call(rbind, list(...)).

Il peut prendre une liste de lists, data.framesou data.tables en entrée.

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)

Cela renvoie un data.tablehérite de data.frame.

Si vous voulez vraiment revenir à une utilisation data.frameas.data.frame(DT)

Le tibblepackage a une fonction enframe()qui résout ce problème en contraignant des listobjets imbriqués à des objets imbriqués tibble(trame de données "bien rangée"). Voici un bref exemple de R pour 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]>

Étant donné que vous avez plusieurs nids dans votre liste, lvous pouvez utiliser le unlist(recursive = FALSE)pour supprimer l'imbrication inutile pour obtenir une seule liste hiérarchique, puis passer à enframe(). J'utilise tidyr::unnest()pour déloger la sortie dans un bloc de données "rangé" à un seul niveau, qui a vos deux colonnes (une pour le groupe nameet une pour les observations avec les groupes value). Si vous voulez des colonnes qui s'étendent, vous pouvez ajouter une colonne en utilisant add_column()qui répète simplement l'ordre des valeurs 132 fois. Ensuite, juste spread()les valeurs.

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>

Selon la structure de vos listes, certaines tidyverseoptions fonctionnent bien avec des listes de longueurs inégales:

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

Vous pouvez également mélanger des vecteurs et des trames de données:

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 donne le même résultat que l'exemple plyr ci-dessus:

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)

rendements:

  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 vous n'aviez presque plus de pixels, vous pouvez tout faire en 1 ligne avec refonte ().

Cette méthode utilise un tidyversepackage ( purrr ).

La liste:

x <- as.list(mtcars)

Le convertir en un bloc de données (un tibbleplus spécifiquement):

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

Étendre la réponse de @ Marek: si vous voulez éviter que les chaînes soient transformées en facteurs et que l'efficacité ne soit pas un problème, essayez

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

Pour le cas général des listes profondément imbriquées avec 3 niveaux ou plus comme ceux obtenus à partir d'un JSON imbriqué:

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

considérez d'abord l'approche de melt()convertir la liste imbriquée dans un format grand:

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

suivi par dcast()puis de nouveau large dans un ensemble de données bien rangé où chaque variable forme une colonne et chaque observation forme une ligne:

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

Plus de réponses, ainsi que des délais dans la réponse à cette question: Quelle est la façon la plus efficace de caster une liste en tant que bloc de données?

Le moyen le plus rapide, qui ne produit pas une trame de données avec des listes plutôt que des vecteurs pour les colonnes semble être (d'après la réponse 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]])))

Parfois, vos données peuvent être une liste de listes de vecteurs de même longueur.

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

(Les vecteurs internes pourraient également être des listes, mais je simplifie pour faciliter la lecture).

Ensuite, vous pouvez apporter la modification suivante. N'oubliez pas que vous pouvez annuler la liste d'un niveau à la fois:

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

Utilisez maintenant votre méthode préférée mentionnée dans les autres réponses:

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

C'est ce qui a finalement fonctionné pour moi:

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)

Pour une solution parallèle (multicœur, multisession, etc.) utilisant une purrrfamille de solutions, utilisez:

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

Où l est la liste.

Pour comparer les plus efficaces, plan()vous pouvez utiliser:

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

La commande simple suivante a fonctionné pour moi:

myDf <- as.data.frame(myList)

Référence ( réponse 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"

Mais cela échouera s'il n'est pas évident de convertir la liste en un bloc de données:

> 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

Remarque : La réponse est vers le titre de la question et peut ignorer certains détails de la question

Un moyen court (mais peut-être pas le plus rapide) de le faire serait d'utiliser la base r, car une trame de données n'est qu'une liste de vecteurs de longueur égale . Ainsi, la conversion entre votre liste d'entrées et un data.frame 30 x 132 serait:

df <- data.frame(l)

De là, nous pouvons le transposer dans une matrice de 132 x 30, et le reconvertir en une trame de données:

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

En une ligne:

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

Les noms d'utilisateur seront assez ennuyeux à regarder, mais vous pouvez toujours renommer ceux avec

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

Que diriez-vous d'utiliser la map_fonction avec une forboucle? Voici ma solution:

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

où map_dfrconvertir chacun des éléments de la liste en un data.frame puisrbind complètement.

Dans votre cas, je suppose que ce serait:

converted_list <- list_to_df(l)