Dictionnaire de style de remplacer plusieurs éléments

J'ai un gros volumes de données.trame de données de caractère que je veux convertir basé sur ce qui est communément appelé un dictionnaire dans d'autres langues.

Actuellement, je suis aller à ce sujet comme suit:

foo <- data.frame(snp1 = c("AA", "AG", "AA", "AA"), snp2 = c("AA", "AT", "AG", "AA"), snp3 = c(NA, "GG", "GG", "GC"), stringsAsFactors=FALSE)
foo <- replace(foo, foo == "AA", "0101")
foo <- replace(foo, foo == "AC", "0102")
foo <- replace(foo, foo == "AG", "0103")

Cela fonctionne bien, mais il n'est évidemment pas jolie et semble idiot de répéter le replace déclaration chaque fois que je veux remplacer un élément dans les données.cadre.

Est-il une meilleure façon de le faire depuis que j'ai un dictionnaire d'environ 25 paires clé/valeur?

InformationsquelleAutor Stedy | 2011-09-25
  1. 27
    map = setNames(c("0101", "0102", "0103"), c("AA", "AC", "AG"))
foo[] <- map[unlist(foo)]

    en supposant que map couvre tous les cas de foo. Cela permettrait de se sentir moins comme un "hack" et être plus efficace dans le temps et l'espace si foo ont été d'une matrice (de caractères()), puis

    matrix(map[foo], nrow=nrow(foo), dimnames=dimnames(foo))

    De la matrice et de la trame de données de variantes aller à l'encontre de R 2^31-1 de limite de taille de vecteur quand il y a des millions de Snp et des milliers d'échantillons.

    InformationsquelleAutor Martin Morgan
  2. 30

    Si vous êtes ouvert à l'aide de paquets, plyr est très populaire et a portée de main ce mapvalues() fonction qui va faire exactement ce que vous cherchez:

    foo <- mapvalues(foo, from=c("AA", "AC", "AG"), to=c("0101", "0102", "0103"))

    Noter que cela fonctionne pour les types de données de toutes sortes, pas seulement des chaînes de caractères.

    • Malheureusement, cela déclenche une Erreur dans plyr::mapvalues(foo, à partir de = c("AA", "AC", "AG"), de = c("0101", : x doit être atomique vecteur. Ceci est également documentée dans ?mapvalues.
    InformationsquelleAutor c.gutierrez
  3. 13

    Ici est une solution rapide

    dict = list(AA = '0101', AC = '0102', AG = '0103')
foo2 = foo
for (i in 1:3){foo2 <- replace(foo2, foo2 == names(dict[i]), dict[i])}
    • quelqu'un peut-il expliquer le silence de downvote???
    • J'aime cette réponse, car elle garde les clés et les valeurs de l'ensemble. Avoir les clés et les valeurs du caractère distinct des vecteurs signifie que si vous prenez la commande de l'un des vecteurs de mal, votre dictionnaire silencieusement mislabels tous mal ordonnée entrées.
    • Seule différence, je suggère, c'est d'utiliser des R vectorisé notation sur la 3e ligne, par exemple: sapply(1:3, la fonction(i) remplacer(foo2, foo2 == noms(dict[i]), dict[i]))
    • *apply fonctions ne sont PAS les mêmes que vectorisé.
    InformationsquelleAutor Ramnath
  4. 5

    Voici quelque chose de simple qui fera le travail:

    key <- c('AA','AC','AG')
val <- c('0101','0102','0103')

lapply(1:3,FUN = function(i){foo[foo == key[i]] <<- val[i]})
foo

 snp1 snp2 snp3
1 0101 0101 <NA>
2 0103   AT   GG
3 0101 0103   GG
4 0101 0101   GC

    lapply affichera une liste, dans ce cas, nous ne se soucient réellement. Vous pouvez affecter le résultat de quelque chose si vous voulez, et puis il suffit de le jeter. Je suis une itération sur les indices ici, mais vous pouvez tout aussi facilement placer la clé/vals-les-bains dans une liste eux-mêmes et itérer sur eux directement. Notez l'utilisation de la cession globale avec <<-.

    J'ai bricolé un moyen de le faire avec mapply mais ma première tentative n'a pas fonctionné, donc je suis passé. Je soupçonne une solution avec mapply est possible, si.

    • je ne le conseille pas l'utilisation de la cession globale de l'opérateur <<-.
    • D'accord, <<- peut être risqué, mais il n'est pas intrinsèquement mauvais.
    • C'est la seule réponse qui puisse s'occuper de la variante où l'original avait les clés de 0:2 et la tâche était de se convertir à caractère équivalent des valeurs. Le plus voté réponse a échoué car 0 n'est pas acceptable de l'index. Ramnaths et c.gutierrez réponses aussi échoué dans mes mains. (Je n'ai pas testé toutes les réponses.) C'est le lien à la question: stackoverflow.com/questions/49504035/...
    InformationsquelleAutor joran
  5. 5

    Note cette réponse qui a commencé comme une tentative pour résoudre le problème bien plus simple posté dans Comment remplacer toutes les valeurs dans le bloc de données avec un vecteur de valeurs?. Malheureusement, cette question a été fermé comme un double de la question. Donc, je vais essayer de proposer une solution basée sur le remplacement des niveaux des facteurs pour les deux cas, ici.

    Dans le cas où il n'est qu'un vecteur (ou une trame de données de la colonne)
    dont les valeurs doivent être remplacés et il n'y a pas d'objections à l'utilisation du facteur, nous pouvons forcer le vecteur de facteur et de modifier les niveaux de facteurs comme l'exige:

    x <- c(1, 1, 4, 4, 5, 5, 1, 1, 2)
x <- factor(x)
x
#[1] 1 1 4 4 5 5 1 1 2
#Levels: 1 2 4 5
replacement_vec <- c("A", "T", "C", "G")
levels(x) <- replacement_vec
x
#[1] A A C C G G A A T
#Levels: A T C G

    À l'aide de la forcatsle paquet de ce qui peut être fait dans un one-liner:

    x <- c(1, 1, 4, 4, 5, 5, 1, 1, 2)
forcats::lvls_revalue(factor(x), replacement_vec)
#[1] A A C C G G A A T
#Levels: A T C G

    En cas tous valeurs de plusieurs colonnes d'un bloc de données doivent être remplacés, l'approche peut être étendue. 

    foo <- data.frame(snp1 = c("AA", "AG", "AA", "AA"), 
                  snp2 = c("AA", "AT", "AG", "AA"), 
                  snp3 = c(NA, "GG", "GG", "GC"), 
                  stringsAsFactors=FALSE)

level_vec <- c("AA", "AC", "AG", "AT", "GC", "GG")
replacement_vec <- c("0101", "0102", "0103", "0104", "0302", "0303")
foo[] <- lapply(foo, function(x) forcats::lvls_revalue(factor(x, levels = level_vec), 
                                                       replacement_vec))
foo
#  snp1 snp2 snp3
#1 0101 0101 <NA>
#2 0103 0104 0303
#3 0101 0103 0303
#4 0101 0101 0302

    Noter que level_vec et replacement_vec doivent avoir des longueurs égales.

    Plus important encore, level_vec devrait être complète , c'est à dire, inclure toutes les valeurs possibles dans les colonnes de l'original de la trame de données. (Utiliser unique(sort(unlist(foo))) à vérifier). Sinon, toutes les valeurs manquantes seront contraints de <NA>. Notez que c'est aussi une exigence pour Martin Morgans réponse.

    Donc, si il n'y a que peu de valeurs différentes pour être remplacé, vous serez probablement mieux avec l'une des autres réponses, par exemple, Ramnath de l'.

    InformationsquelleAutor Uwe
  6. 1

    Utilisé @Ramnath la réponse ci-dessus, mais le fait de lire (ce qui doit être remplacé et ce sera remplacé par) à partir d'un fichier et d'utiliser gsub plutôt que de le remplacer.

    hrw <- read.csv("hgWords.txt", header=T, stringsAsFactor=FALSE, encoding="UTF-8", sep="\t") 

for (i in nrow(hrw)) 
{
document <- gsub(hrw$from[i], hrw$to[i], document, ignore.case=TRUE)
}

    hgword.txt contient les éléments suivants, séparés par des tabulations 

    "from"  "to"
"AA"    "0101"
"AC"    "0102"
"AG"    "0103"
    InformationsquelleAutor Fathi Alwosaibi
  7. 1

    Depuis qu'il a été quelques années depuis la dernière réponse, et une nouvelle question s'est posée ce soir sur ce sujet et un modérateur fermé, je vais l'ajouter ici. L'affiche a un grand bloc de données contenant 0, 1, et 2, et veut les modifier à AA, AB et BB respectivement.

    Utilisation plyr:

    > df <- data.frame(matrix(sample(c(NA, c("0","1","2")), 100, replace = TRUE), 10))
> df
     X1   X2   X3 X4   X5   X6   X7   X8   X9  X10
1     1    2 <NA>  2    1    2    0    2    0    2
2     0    2    1  1    2    1    1    0    0    1
3     1    0    2  2    1    0 <NA>    0    1 <NA>
4     1    2 <NA>  2    2    2    1    1    0    1
... to 10th row

> df[] <- lapply(df, as.character)

    Créer une fonction sur le bloc de données à l'aide de revalue pour remplacer plusieurs termes:

    > library(plyr)
> apply(df, 2, function(x) {x <- revalue(x, c("0"="AA","1"="AB","2"="BB")); x})
      X1   X2   X3   X4   X5   X6   X7   X8   X9   X10 
 [1,] "AB" "BB" NA   "BB" "AB" "BB" "AA" "BB" "AA" "BB"
 [2,] "AA" "BB" "AB" "AB" "BB" "AB" "AB" "AA" "AA" "AB"
 [3,] "AB" "AA" "BB" "BB" "AB" "AA" NA   "AA" "AB" NA  
 [4,] "AB" "BB" NA   "BB" "BB" "BB" "AB" "AB" "AA" "AB"
... and so on
    • Il ressemble à la saisie de données.cadre et votre sortie est une matrice. Je pense que l'on peut contraindre en arrière à la fin, cependant.
    InformationsquelleAutor mysteRious
  8. 1

    Nous pouvons également utiliser dplyr::case_when

    library(dplyr)

foo %>%
   mutate_all(~case_when(. == "AA" ~ "0101", 
                         . == "AC" ~ "0102", 
                         . == "AG" ~ "0103", 
                         TRUE ~ .))

#  snp1 snp2 snp3
#1 0101 0101 <NA>
#2 0103   AT   GG
#3 0101 0103   GG
#4 0101 0101   GC

    Il vérifie l'état et la remplace par la valeur correspondante si la condition est TRUE. On peut ajouter des conditions supplémentaires si nécessaire et avec TRUE ~ . nous conservons les valeurs qu'elle est si aucun de l'état est mis en correspondance. Si nous voulons changer à NA au lieu de cela, nous pouvons supprimer la dernière ligne. 

    foo %>%
  mutate_all(~case_when(. == "AA" ~ "0101", 
                        . == "AC" ~ "0102", 
                        . == "AG" ~ "0103"))

#  snp1 snp2 snp3
#1 0101 0101 <NA>
#2 0103 <NA> <NA>
#3 0101 0103 <NA>
#4 0101 0101 <NA>

    Cela va changer les valeurs de NA si aucun de la condition ci-dessus est satisfaite.

    Une autre option à l'aide seulement de la base de R est de créer un lookup dataframe avec les anciennes et nouvelles valeurs, unlist le dataframe, match avec les valeurs anciennes, obtenir les nouvelles valeurs et de les remplacer. 

    lookup <- data.frame(old_val = c("AA", "AC", "AG"), 
                     new_val = c("0101", "0102", "0103"))

foo[] <- lookup$new_val[match(unlist(foo), lookup$old_val)]
    InformationsquelleAutor Ronak Shah
  9. 0

    À l'aide de dplyr::recode:

    library(dplyr)

mutate_all(foo, funs(recode(., "AA" = "0101", "AC" = "0102", "AG" = "0103",
                            .default = NA_character_)))

#   snp1 snp2 snp3
# 1 0101 0101 <NA>
# 2 0103 <NA> <NA>
# 3 0101 0103 <NA>
# 4 0101 0101 <NA>
    InformationsquelleAutor zx8754