Comment faire pour convertir une liste de vecteurs de longueurs différentes pour un produit de bloc de données dans R?

J'ai une (assez longue) liste de vecteurs. Les vecteurs sont constitués de mots russes que j'ai obtenu en utilisant le strsplit() fonction de phrases.

La suivante est ce que head() retourne:

[[1]]
[1] "модно"     "создавать" "резюме"    "в"         "виде"     

[[2]]
[1] "ты"        "начианешь" "работать"  "с"         "этими"    

[[3]]
[1] "модно"            "называть"         "блогер-рилейшенз" "―"                "начинается"       "задолго"         

[[4]]
[1] "видел" "по"    "сыну," "что"   "он"   

[[5]]
[1] "четырнадцать," "я"             "поселился"     "на"            "улице"        

[[6]]
[1] "широко"     "продолжали" "род."

Note les vecteurs sont de longueur différente.

Ce que je veux, c'est être capable de lire les premiers mots de chaque phrase, le deuxième mot, la troisième, etc.

Le résultat souhaité serait quelque chose comme ceci:

    P1              P2           P3                 P4    P5           P6
[1] "модно"         "создавать"  "резюме"           "в"   "виде"       NA
[2] "ты"            "начианешь"  "работать"         "с"   "этими"      NA
[3] "модно"         "называть"   "блогер-рилейшенз" "―"   "начинается" "задолго"         
[4] "видел"         "по"         "сыну,"            "что" "он"         NA
[5] "четырнадцать," "я"          "поселился"        "на"  "улице"      NA
[6] "широко"        "продолжали" "род."             NA    NA           NA

J'ai essayé de l'utiliser juste data.frame() mais cela ne fonctionne pas parce que les lignes sont de longueur différente. J'ai aussi essayé rbind.fill() de la plyr paquet, mais cette fonction peut uniquement traiter des matrices.

J'ai trouvé quelques autres questions ici (c'est là que j'ai eu l' plyr aide d'), mais ceux-ci étaient tous sur les combinant, par exemple, deux blocs de données de taille différente.

Merci pour votre aide.

peut-être sapply(1:length(your_list),function(j) yourlist[[j]][1]) ?

InformationsquelleAutor Ico | 2013-03-04

dataframe r vector

36

essayez ceci:
```
word.list <- list(letters[1:4], letters[1:5], letters[1:2], letters[1:6])
n.obs <- sapply(word.list, length)
seq.max <- seq_len(max(n.obs))
mat <- t(sapply(word.list, "[", i = seq.max))
```
le truc, c'est que,
```
c(1:2)[1:4]
```
retourne le vecteur + deux NAs
- cela pourrait encore être condensée en une seule ligne par: sapply(word.list, '[', seq(max(sapply(word.list, length)))) (comme indiqué ici)
- Pour ceux qui voudraient l'utiliser @Arun est une solution en ligne, notez qu'il doit y avoir une transposition t() pour créer les colonnes appropriées, comme dans la question d'origine.
InformationsquelleAutor adibender
73

Un liner avec plyr
```
plyr::ldply(word.list, rbind)
```
- Je pense que cette réponse est la meilleure et la plus concise!
InformationsquelleAutor Ramnath
11

Vous pouvez faire quelque chose comme ceci :
```
## Example data
l <- list(c("a","b","c"), c("a2","b2"), c("a3","b3","c3","d3"))
## Compute maximum length
max.length <- max(sapply(l, length))
## Add NA values to list elements
l <- lapply(l, function(v) { c(v, rep(NA, max.length-length(v)))})
## Rbind
do.call(rbind, l)
```
Qui donne :
```
     [,1] [,2] [,3] [,4]
[1,] "a"  "b"  "c"  NA  
[2,] "a2" "b2" NA   NA  
[3,] "a3" "b3" "c3" "d3"
```
- Aha, ce que l'on a oublié (Juba et moi), c'est que vous n'avez pas besoin de "remplir" les premiers éléments de la liste avec NA valeurs. Le sapply extrait de code que j'ai mis dans un commentaire renvoie NA pour la liste des éléments qui sont plus courtes que la demande de valeur de l'indice. N'est-ce pas gentil de sapply ne pas tomber en panne? 🙂
InformationsquelleAutor juba
11

Une autre option est stri_list2matrix de library(stringi)
```
library(stringi)
stri_list2matrix(l, byrow=TRUE)
#    [,1] [,2] [,3] [,4]
#[1,] "a"  "b"  "c"  NA  
#[2,] "a2" "b2" NA   NA  
#[3,] "a3" "b3" "c3" "d3"
```
REMARQUE: les Données de @juba post.

Ou comme @Valentin mentionné dans les commentaires
```
sapply(l, "length<-", max(lengths(l)))
```
- Je pense que votre élégant de la base de R solution sur here vaut la peine d'être mentionné ainsi: sapply(l, "length<-", max(lengths(l)))
InformationsquelleAutor akrun
4

vous pouvez également utiliser rbindlist() de données.table-paquet.

Convertir les vecteurs de données.table ou les données.cadre et de la transposer (pas sûr si cela réduit la vitesse d'un lot) avec l'aide de lapply(). Puis les lier avec rbindlist() de remplissage des cellules manquantes avec NA:
```
l = list(c("a","b","c"), c("a2","b2"), c("a3","b3","c3","d3"))
dt = rbindlist(lapply(l, function(x) data.table(t(x))),
     fill = TRUE)
```
InformationsquelleAutor andrasz

Une autre option pourrait consister à définir une fonction comme ceci (il faudrait imiter rbind.fill) ou l'utiliser directement à partir de rowr package:

cbind.fill <- function(...){
  nm <- list(...) 
  nm <- lapply(nm, as.matrix)
  n <- max(sapply(nm, nrow)) 
  do.call(cbind, lapply(nm, function (x) 
    rbind(x, matrix(, n-nrow(x), ncol(x))))) 
}

Ce qui concerne

InformationsquelleAutor jgarces

Vous devez vous connecter pour publier un commentaire.