do.call (rbind, list) pour un nombre impair de colonnes

J'ai une liste, chaque élément étant un caractère de vecteur, de longueurs différentes
Je voudrais lier les données sous forme de lignes, de sorte que les noms de colonne "line up" et si vous disposez de plus de données, puis créer la colonne et s'il manque de données, puis créer NAs

Ci-dessous est un exemple fictif de données, je travaille avec

x <- list()
x[[1]] <- letters[seq(2,20,by=2)]
names(x[[1]]) <- LETTERS[c(1:length(x[[1]]))]
x[[2]] <- letters[seq(3,20, by=3)]
names(x[[2]]) <- LETTERS[seq(3,20, by=3)]
x[[3]] <- letters[seq(4,20, by=4)]
names(x[[3]]) <- LETTERS[seq(4,20, by=4)]

La ligne ci-dessous devrait normalement être ce que je ferais si j'étais sûr que le format de chaque élément a été la même...

do.call(rbind,x)

J'espérais que quelqu'un était venu avec une belle petite solution qui correspond à la colonne des noms et remplit les blancs avec NAs, tandis que l'ajout de nouvelles colonnes si dans le processus de liaison de nouvelles colonnes sont trouvés...

source d'informationauteur h.l.m

  1. 25

    rbind.fill est un jeu génial de fonction qui fait vraiment du bien sur la liste de données.les cadres. Mais à mon humble avis, pour ce cas, il peut être fait beaucoup plus rapidement lorsque la liste contient seulement (nommé) de vecteurs.

    La rbind.fill façon

    require(plyr)
rbind.fill(lapply(x,function(y){as.data.frame(t(y),stringsAsFactors=FALSE)}))

    Façon plus simple (et efficace pour ce scénario au moins):

    rbind.named.fill <- function(x) {
    nam <- sapply(x, names)
    unam <- unique(unlist(nam))
    len <- sapply(x, length)
    out <- vector("list", length(len))
    for (i in seq_along(len)) {
        out[[i]] <- unname(x[[i]])[match(unam, nam[[i]])]
    }
    setNames(as.data.frame(do.call(rbind, out), stringsAsFactors=FALSE), unam)
}

    Fondamentalement, nous obtenons total des noms uniques pour former les colonnes de la finale des données.cadre. Ensuite, nous créons une liste avec longueur = l'entrée et il vous suffit de remplir le reste des valeurs avec NA. C'est probablement la "délicate" de la partie que nous avons de faire correspondre les noms tout en remplissant NA. Et puis, nous avons mis les noms une fois enfin pour les colonnes (qui peut être définie par référence à l'aide de setnames de data.table paquet aussi bien en cas de besoin).

    Maintenant, pour certains d'analyse comparative:

    De données:

    # generate some huge random data:
set.seed(45)
sample.fun <- function() {
    nam <- sample(LETTERS, sample(5:15))
    val <- sample(letters, length(nam))
    setNames(val, nam)  
}
ll <- replicate(1e4, sample.fun())

    Fonctions:

    # plyr's rbind.fill version:
rbind.fill.plyr <- function(x) {
    rbind.fill(lapply(x,function(y){as.data.frame(t(y),stringsAsFactors=FALSE)}))
}

rbind.named.fill <- function(x) {
    nam <- sapply(x, names)
    unam <- unique(unlist(nam))
    len <- sapply(x, length)
    out <- vector("list", length(len))
    for (i in seq_along(len)) {
        out[[i]] <- unname(x[[i]])[match(unam, nam[[i]])]
    }
    setNames(as.data.frame(do.call(rbind, out), stringsAsFactors=FALSE), unam)
}

    Mise à jour (ajout GSee de la fonction en tant que bien):

    foo <- function (...) 
{
  dargs <- list(...)
  all.names <- unique(names(unlist(dargs)))
  out <- do.call(rbind, lapply(dargs, `[`, all.names))
  colnames(out) <- all.names
  as.data.frame(out, stringsAsFactors=FALSE)
}

    Benchmarking:

    require(microbenchmark)
microbenchmark(t1 <- rbind.named.fill(ll), 
               t2 <- rbind.fill.plyr(ll), 
               t3 <- do.call(foo, ll), times=10)
identical(t1, t2) # TRUE
identical(t1, t3) # TRUE

Unit: milliseconds
                       expr        min         lq     median         uq        max neval
 t1 <- rbind.named.fill(ll)   243.0754   258.4653   307.2575   359.4332   385.6287    10
  t2 <- rbind.fill.plyr(ll) 16808.3334 17139.3068 17648.1882 17890.9384 18220.2534    10
     t3 <- do.call(foo, ll)   188.5139   204.2514   229.0074   339.6309   359.4995    10
  2. 8

    Si vous voulez que le résultat soit une matrice...

    Récemment, j'ai écrit cette fonction pour un collègue qui voulait rbind vecteurs dans une matrice.

    foo <- function (...) 
{
  dargs <- list(...)
  if (!all(vapply(dargs, is.vector, TRUE))) 
      stop("all inputs must be vectors")
  if (!all(vapply(dargs, function(x) !is.null(names(x)), TRUE))) 
      stop("all input vectors must be named.")
  all.names <- unique(names(unlist(dargs)))
  out <- do.call(rbind, lapply(dargs, `[`, all.names))
  colnames(out) <- all.names
  out
}

R > do.call(foo, x)
     A   B   C   D   E   F   G   H   I   J   L   O   R   P   T  
[1,] "b" "d" "f" "h" "j" "l" "n" "p" "r" "t" NA  NA  NA  NA  NA 
[2,] NA  NA  "c" NA  NA  "f" NA  NA  "i" NA  "l" "o" "r" NA  NA 
[3,] NA  NA  NA  "d" NA  NA  NA  "h" NA  NA  "l" NA  NA  "p" "t"