Remodeler la troisième colonne du bloc de données de la matrice (“long” à “large” format)

J'ai un data.frame qui ressemble à ceci.

x a 1 
x b 2 
x c 3 
y a 3 
y b 3 
y c 2

Ce que je veux c'sous forme de matrice afin que je puisse le donner à heatmap faire un terrain. Le résultat devrait ressembler à quelque chose comme:

    a    b    c
x   1    2    3
y   3    3    2

J'ai essayé cast de le remodeler paquet et j'ai essayé d'écrire un manuel de fonction pour le faire, mais je ne semble pas être en mesure d'obtenir ce droit.

a également une grande réponse à ce sujet ici: stackoverflow.com/a/14515736/210673

InformationsquelleAutor MalteseUnderdog | 2012-03-08

170

Il y a beaucoup de façons de le faire. Cette réponse commence par mes façons préférées, mais aussi la collecte de diverses manières à partir de réponses à des questions similaires dispersés autour de ce site.
```
tmp <- data.frame(x=gl(2,3, labels=letters[24:25]),
                  y=gl(3,1,6, labels=letters[1:3]), 
                  z=c(1,2,3,3,3,2))
```
À l'aide de la tidyverse:

La fraîcheur de la nouvelle façon de faire, c'est avec spread de tidyr. Elle renvoie une trame de données, ce qui est probablement ce que la plupart des lecteurs de cette réponse le souhaitez. Pour une heatmap, cependant, vous devez convertir ce pour une matrice réelle.
```
library(tidyr)
spread(tmp, y, z)
##   x a b c
## 1 x 1 2 3
## 2 y 3 3 2
```
À l'aide de reshape2:

L'une des premières étapes vers la tidyverse était le reshape2 paquet. J'ai toujours pense que pour beaucoup de remodelage des tâches, la melt et *cast fonctions sont plus propres et plus simple que la tidyverse façons.

Pour obtenir une matrice d'utilisation acast:
```
library(reshape2)
acast(tmp, x~y, value.var="z")
##   a b c
## x 1 2 3
## y 3 3 2
```
Ou pour obtenir un bloc de données, l'utilisation dcast, comme ici: Remodeler les données pour les valeurs dans une colonne.
```
dcast(tmp, x~y, value.var="z")
##   x a b c
## 1 x 1 2 3
## 2 y 3 3 2
```
À l'aide de plyr:

Entre reshape2 et la tidyverse est venu plyr, avec la daply fonction, comme illustré ici: https://stackoverflow.com/a/7020101/210673
```
library(plyr)
daply(tmp, .(x, y), function(x) x$z)
##    y
## x   a b c
##   x 1 2 3
##   y 3 3 2
```
En utilisant la matrice d'indexation:

C'est un peu vieille école, mais c'est une belle démonstration d'indexation de matrice, qui peut être très utile dans certaines situations.
```
with(tmp, {
  out <- matrix(nrow=nlevels(x), ncol=nlevels(y),
                dimnames=list(levels(x), levels(y)))
  out[cbind(x, y)] <- z
  out
})
```
À l'aide de xtabs:
```
xtabs(z~x+y, data=tmp)
```
À l'aide d'une matrice creuse:

Il y a aussi sparseMatrix dans le Matrix paquet, comme on le voit ici: R - convertir GRANDE table dans la matrice sont les noms des colonnes
```
with(tmp, sparseMatrix(i = as.numeric(x), j=as.numeric(y), x=z,
                       dimnames=list(levels(x), levels(y))))
## 2 x 3 sparse Matrix of class "dgCMatrix"
##   a b c
## x 1 2 3
## y 3 3 2
```
À l'aide de reshape:

Vous pouvez également utiliser la base de la fonction R reshape, comme suggéré ici: Convertir un tableau en sont les noms des colonnes de la matrice, si vous avez à faire un peu de manipulation par la suite, de supprimer une des colonnes supplémentaires et d'obtenir les noms de droit (non représenté).
```
reshape(tmp, idvar="x", timevar="y", direction="wide")
##   x z.a z.b z.c
## 1 x   1   2   3
## 4 y   3   3   2
```
- acast(tmp, x~y, value.var="z") donnera une matrice de sortie, avec x de la ligne.les noms de
- Pouvez-vous commenter sur les avantages/inconvénients des différentes méthodes?
- Dans la plupart des petites séries de données, la principale considération doit être de codage dans un langage clair à l'avenir, les analystes (y compris les futurs vous) et les moins sensibles à l'homme de codage des erreurs. Bien que cela dépendra de vos forces et de vos besoins, en général, il est considéré comme l'un des points forts de la nouvelle tidyverse ensemble de paquets. Une autre considération (mais pas vraiment un avantage/inconvénient) est de savoir si vous voulez une matrice ou d'un bloc de données comme un résultat; cette question en fait la demande, pour une matrice, et vous pouvez le voir dans la réponse que certaines techniques de donner directement alors que certains donnent une trame de données.
- Temps de calcul peuvent également être une considération pour les grands ensembles de données, en particulier lorsque le code doit être répétée plusieurs fois ou sur plusieurs ensembles de données. Je soupçonne que dépend, en partie, bien que, sur les caractéristiques spécifiques de l'ensemble de données. Si c'est une préoccupation pour vous, je vous suggère de poser une autre question au sujet de l'optimisation de votre situation particulière; des questions comme ça à un moment ont été, comme l'herbe à chat pour cette foule. 🙂 Mais je vais répéter mon point précédent: optimisation pour l'utilisateur est (généralement) plus important que l'optimisation de l'ordinateur.
InformationsquelleAutor Aaron

La question est de quelques années, mais peut-être que certaines personnes sont toujours intéressés par les réponses alternatives.

Si vous ne voulez pas charger tous les packages, vous pouvez utiliser cette fonction:

#' Converts three columns of a data.frame into a matrix -- e.g. to plot 
#' the data via image() later on. Two of the columns form the row and
#' col dimensions of the matrix. The third column provides values for
#' the matrix.
#' 
#' @param data data.frame: input data
#' @param rowtitle string: row-dimension; name of the column in data, which distinct values should be used as row names in the output matrix
#' @param coltitle string: col-dimension; name of the column in data, which distinct values should be used as column names in the output matrix
#' @param datatitle string: name of the column in data, which values should be filled into the output matrix
#' @param rowdecreasing logical: should the row names be in ascending (FALSE) or in descending (TRUE) order?
#' @param coldecreasing logical: should the col names be in ascending (FALSE) or in descending (TRUE) order?
#' @param default_value numeric: default value of matrix entries if no value exists in data.frame for the entries
#' @return matrix: matrix containing values of data[[datatitle]] with rownames data[[rowtitle]] and colnames data[coltitle]
#' @author Daniel Neumann
#' @date 2017-08-29
data.frame2matrix = function(data, rowtitle, coltitle, datatitle, 
rowdecreasing = FALSE, coldecreasing = FALSE,
default_value = NA) {
# check, whether titles exist as columns names in the data.frame data
if ( (!(rowtitle%in%names(data))) 
|| (!(coltitle%in%names(data))) 
|| (!(datatitle%in%names(data))) ) {
stop('data.frame2matrix: bad row-, col-, or datatitle.')
}
# get number of rows in data
ndata = dim(data)[1]
# extract rownames and colnames for the matrix from the data.frame
rownames = sort(unique(data[[rowtitle]]), decreasing = rowdecreasing)
nrows = length(rownames)
colnames = sort(unique(data[[coltitle]]), decreasing = coldecreasing)
ncols = length(colnames)
# initialize the matrix
out_matrix = matrix(NA, 
nrow = nrows, ncol = ncols,
dimnames=list(rownames, colnames))
# iterate rows of data
for (i1 in 1:ndata) {
# get matrix-row and matrix-column indices for the current data-row
iR = which(rownames==data[[rowtitle]][i1])
iC = which(colnames==data[[coltitle]][i1])
# throw an error if the matrix entry (iR,iC) is already filled.
if (!is.na(out_matrix[iR, iC])) stop('data.frame2matrix: double entry in data.frame')
out_matrix[iR, iC] = data[[datatitle]][i1]
}
# set empty matrix entries to the default value
out_matrix[is.na(out_matrix)] = default_value
# return matrix
return(out_matrix)
}

Comment cela fonctionne:

myData = as.data.frame(list('dim1'=c('x', 'x', 'x', 'y','y','y'),
'dim2'=c('a','b','c','a','b','c'),
'values'=c(1,2,3,3,3,2))) 
myMatrix = data.frame2matrix(myData, 'dim1', 'dim2', 'values')
myMatrix
>   a b c
> x 1 2 3
> y 3 3 2

InformationsquelleAutor daniel.neumann

de la base de R, `unstack`

unstack(df, V3 ~ V2)
#   a b c
# 1 1 2 3
# 2 3 3 2

Cela peut ne pas être une solution générale, mais fonctionne bien dans ce cas.

de données

df<-structure(list(V1 = structure(c(1L, 1L, 1L, 2L, 2L, 2L), .Label = c("x", 
"y"), class = "factor"), V2 = structure(c(1L, 2L, 3L, 1L, 2L, 
3L), .Label = c("a", "b", "c"), class = "factor"), V3 = c(1L, 
2L, 3L, 3L, 3L, 2L)), .Names = c("V1", "V2", "V3"), class = "data.frame", row.names = c(NA, 
-6L))

InformationsquelleAutor lebatsnok

Un souci d'exhaustivité, il y a un tapply() solution autour de.

with(d, tapply(z, list(x, y), sum))
#   a b c
# x 1 2 3
# y 3 3 2

Données

d <- structure(list(x = structure(c(1L, 1L, 1L, 2L, 2L, 2L), .Label = c("x", 
"y"), class = "factor"), y = structure(c(1L, 2L, 3L, 1L, 2L, 
3L), .Label = c("a", "b", "c"), class = "factor"), z = c(1, 2, 
3, 3, 3, 2)), class = "data.frame", row.names = c(NA, -6L))

InformationsquelleAutor jay.sf

1

La tidyr package à partir de la tidyverse a une excellente fonction qui fait cela.

En supposant que les variables sont nommées v1, v2 et v3, de gauche à droite, et vous trame de données est nommée dat:
```
dat %>% 
spread(key = v2,
value = v3)
```
Ta da!
- voir la réponse de @Aaron
- En quelque sorte réussi à rater le cadre à la fin où il a couvert la propagation. Belle prise, merci.
InformationsquelleAutor Ahsen Omar Majid

Vous devez vous connecter pour publier un commentaire.

de la base de R, unstack

de données

de la base de R, `unstack`