R: gsub, pattern = vecteur et de remplacement = vecteur

Comme le titre, je suis en train d'utiliser gsub où j'utilise un vecteur pour le "motif" et "remplacement". Actuellement, j'ai un code qui ressemble à ceci:

  names(x1) <- gsub("2110027599", "Inv1", names(x1)) #x1 is a data frame
  names(x1) <- gsub("2110025622", "Inv2", names(x1))
  names(x1) <- gsub("2110028045", "Inv3", names(x1))
  names(x1) <- gsub("2110034716", "Inv4", names(x1))
  names(x1) <- gsub("2110069349", "Inv5", names(x1))
  names(x1) <- gsub("2110023264", "Inv6", names(x1))

Ce que j'espère faire quelque chose comme ceci:

  a <- c("2110027599","2110025622","2110028045","2110034716", "2110069349", "2110023264")
  b <- c("Inv1","Inv2","Inv3","Inv4","Inv5","Inv6")
  names(x1) <- gsub(a,b,names(x1))

Je devine qu'il y est une application de fonction quelque part qui peut faire cela, mais je ne suis pas très sûr que l'on puisse l'utiliser!

EDIT: noms(x1) ressemble à ceci (Il y a beaucoup plus de colonnes, mais je vais la laisser sortir):

> names(x1)
  [1] "2110023264A.Ms.Amp"        "2110023264A.Ms.Vol"        "2110023264A.Ms.Watt"       "2110023264A1.Ms.Amp"      
  [5] "2110023264A2.Ms.Amp"       "2110023264A3.Ms.Amp"       "2110023264A4.Ms.Amp"       "2110023264A5.Ms.Amp"      
  [9] "2110023264B.Ms.Amp"        "2110023264B.Ms.Vol"        "2110023264B.Ms.Watt"       "2110023264B1.Ms.Amp"      
 [13] "2110023264Error"           "2110023264E-Total"         "2110023264GridMs.Hz"       "2110023264GridMs.PhV.phsA"
 [17] "2110023264GridMs.PhV.phsB" "2110023264GridMs.PhV.phsC" "2110023264GridMs.TotPFPrc" "2110023264Inv.TmpLimStt"  
 [21] "2110023264InvCtl.Stt"      "2110023264Mode"            "2110023264Mt.TotOpTmh"     "2110023264Mt.TotTmh"      
 [25] "2110023264Op.EvtCntUsr"    "2110023264Op.EvtNo"        "2110023264Op.GriSwStt"     "2110023264Op.TmsRmg"      
 [29] "2110023264Pac"             "2110023264PlntCtl.Stt"     "2110023264Serial Number"   "2110025622A.Ms.Amp"       
 [33] "2110025622A.Ms.Vol"        "2110025622A.Ms.Watt"       "2110025622A1.Ms.Amp"       "2110025622A2.Ms.Amp"      
 [37] "2110025622A3.Ms.Amp"       "2110025622A4.Ms.Amp"       "2110025622A5.Ms.Amp"       "2110025622B.Ms.Amp"       
 [41] "2110025622B.Ms.Vol"        "2110025622B.Ms.Watt"       "2110025622B1.Ms.Amp"       "2110025622Error"          
 [45] "2110025622E-Total"         "2110025622GridMs.Hz"       "2110025622GridMs.PhV.phsA" "2110025622GridMs.PhV.phsB"

Ce que j'espère obtenir de l'est: est-ce

> names(x1)
  [1] "Inv6A.Ms.Amp"        "Inv6A.Ms.Vol"        "Inv6A.Ms.Watt"       "Inv6A1.Ms.Amp"       "Inv6A2.Ms.Amp"      
  [6] "Inv6A3.Ms.Amp"       "Inv6A4.Ms.Amp"       "Inv6A5.Ms.Amp"       "Inv6B.Ms.Amp"        "Inv6B.Ms.Vol"       
 [11] "Inv6B.Ms.Watt"       "Inv6B1.Ms.Amp"       "Inv6Error"           "Inv6E-Total"         "Inv6GridMs.Hz"      
 [16] "Inv6GridMs.PhV.phsA" "Inv6GridMs.PhV.phsB" "Inv6GridMs.PhV.phsC" "Inv6GridMs.TotPFPrc" "Inv6Inv.TmpLimStt"  
 [21] "Inv6InvCtl.Stt"      "Inv6Mode"            "Inv6Mt.TotOpTmh"     "Inv6Mt.TotTmh"       "Inv6Op.EvtCntUsr"   
 [26] "Inv6Op.EvtNo"        "Inv6Op.GriSwStt"     "Inv6Op.TmsRmg"       "Inv6Pac"             "Inv6PlntCtl.Stt"    
 [31] "Inv6Serial Number"   "Inv2A.Ms.Amp"        "Inv2A.Ms.Vol"        "Inv2A.Ms.Watt"       "Inv2A1.Ms.Amp"      
 [36] "Inv2A2.Ms.Amp"       "Inv2A3.Ms.Amp"       "Inv2A4.Ms.Amp"       "Inv2A5.Ms.Amp"       "Inv2B.Ms.Amp"       
 [41] "Inv2B.Ms.Vol"        "Inv2B.Ms.Watt"       "Inv2B1.Ms.Amp"       "Inv2Error"           "Inv2E-Total"        
 [46] "Inv2GridMs.Hz"       "Inv2GridMs.PhV.phsA" "Inv2GridMs.PhV.phsB"

Pouvez-vous donner un exemple de ce qu' names(x1) ressemble?
S'il vous plaît ajouter la sortie de names( x1 ) à la question...
J'ai ajouté les noms de(x1), je vous remercie.

InformationsquelleAutor Wet Feet | 2013-10-17

24

Beaucoup de solutions déjà, en voici un de plus:

La qdap package:
```
library(qdap)
names(x1) <- mgsub(a,b,names(x1))
```
- mapply ne fonctionne pas vraiment car gsub ne fonctionne toujours pas sur les vecteurs, mais le qdap paquets fonctionne parfaitement. Aussi, suis-je le choix de ce que l'on a accepté la réponse.
- Attention: qdap a un nombre énorme de dépendances.
- Je suis tout à fait conscient depuis que je l'ai écrit. Deuxièmement, il n'est pas nécessaire pour votre avertissement. Il est open source et que cette info est énoncé clairement dans la première page de la documentation.
- C'est comme dire "il n'y a pas besoin de l'état de la bibliothèque utilisée dans cette réponse, parce que vous pouvez toujours google la fonction". Bien sûr, l'avertissement peut ne pas être nécessaire, mais il est toujours agréable de savoir sans faire plus de recherche.
InformationsquelleAutor Tyler Rinker
16

De stringr documentation de str_replace_all, "Si vous souhaitez appliquer plusieurs modèles et les remplacements à la même chaîne, de passer un nommé version de modèle."

Ainsi, à l'aide de a, b, et les noms(x1) à partir de ci-dessus
```
library(stringr)
names(b) <- a
str_replace_all(names(x1), b)
```
- C'est une grande découverte et fonctionne à merveille.
InformationsquelleAutor JWilliman

Nouvelle Réponse

Si nous pouvons faire une autre hypothèse, la suivante devrait fonctionner. L'hypothèse est que vous êtes vraiment intéressé à substituer les 10 premiers caractères de chaque valeur dans names(x1).

Ici, je l'ai stocké names(x1) comme un caractère de vecteur nommé "X1". La solution utilise essentiellement substr pour séparer les valeurs de X1 en 2 parties, match pour déterminer l'option de remplacement, et paste de tout remettre ensemble.

a <- c("2110027599", "2110025622", "2110028045",
       "2110034716", "2110069349", "2110023264")
b <- c("Inv1","Inv2","Inv3","Inv4","Inv5","Inv6")

X1pre <- substr(X1, 1, 10)
X1post <- substr(X1, 11, max(nchar(X1)))

paste0(b[match(X1pre, a)], X1post)
#  [1] "Inv6A.Ms.Amp"        "Inv6A.Ms.Vol"        "Inv6A.Ms.Watt"      
#  [4] "Inv6A1.Ms.Amp"       "Inv6A2.Ms.Amp"       "Inv6A3.Ms.Amp"      
#  [7] "Inv6A4.Ms.Amp"       "Inv6A5.Ms.Amp"       "Inv6B.Ms.Amp"       
# [10] "Inv6B.Ms.Vol"        "Inv6B.Ms.Watt"       "Inv6B1.Ms.Amp"      
# [13] "Inv6Error"           "Inv6E-Total"         "Inv6GridMs.Hz"      
# [16] "Inv6GridMs.PhV.phsA" "Inv6GridMs.PhV.phsB" "Inv6GridMs.PhV.phsC"
# [19] "Inv6GridMs.TotPFPrc" "Inv6Inv.TmpLimStt"   "Inv6InvCtl.Stt"     
# [22] "Inv6Mode"            "Inv6Mt.TotOpTmh"     "Inv6Mt.TotTmh"      
# [25] "Inv6Op.EvtCntUsr"    "Inv6Op.EvtNo"        "Inv6Op.GriSwStt"    
# [28] "Inv6Op.TmsRmg"       "Inv6Pac"             "Inv6PlntCtl.Stt"    
# [31] "Inv6Serial Number"   "Inv2A.Ms.Amp"        "Inv2A.Ms.Vol"       
# [34] "Inv2A.Ms.Watt"       "Inv2A1.Ms.Amp"       "Inv2A2.Ms.Amp"      
# [37] "Inv2A3.Ms.Amp"       "Inv2A4.Ms.Amp"       "Inv2A5.Ms.Amp"      
# [40] "Inv2B.Ms.Amp"        "Inv2B.Ms.Vol"        "Inv2B.Ms.Watt"      
# [43] "Inv2B1.Ms.Amp"       "Inv2Error"           "Inv2E-Total"        
# [46] "Inv2GridMs.Hz"       "Inv2GridMs.PhV.phsA" "Inv2GridMs.PhV.phsB"

Vieille Réponse

Si nous pouvons supposer que names(x1) est dans le même ordre que le modèle et le remplacement et qu'il est fondamentalement un un pour un remplacement, vous pourriez être en mesure de s'en tirer avec juste sapply.

Voici un exemple de cette situation: les

Imaginer "des noms(x)" ressemble à quelque chose comme ceci:

X1 <- paste0("A2", a, sequence(length(a)))
X1
# [1] "A221100275991" "A221100256222" "A221100280453" 
# [4] "A221100347164" "A221100693495" "A221100232646"

Voici notre pattern et replacement vecteurs:

a <- c("2110027599", "2110025622", "2110028045", 
       "2110034716", "2110069349", "2110023264")
b <- c("Inv1","Inv2","Inv3","Inv4","Inv5","Inv6")

C'est la façon dont nous pourrions utiliser sapply si ces hypothèses sont valables.

sapply(seq_along(a), function(x) gsub(a[x], b[x], X1[x]))
# [1] "A2Inv11" "A2Inv22" "A2Inv33" "A2Inv44" "A2Inv55" "A2Inv66"

+1 cool haricots Ananda
sapply a bien fonctionné pour moi.

InformationsquelleAutor A5C1D2H2I1M1N2O1R2T1

2

En quelque sorte names<- et match semble beaucoup plus approprié ici...
```
names( x1 ) <- b[ match( names( x1 ) , a ) ]
```
Mais je fais l'hypothèse que les éléments de vecteur a sont réels names de votre data.frame.

Si a est vraiment un motif trouvé dans chacun des names de x1 puis ce grepl approche avec names<- pourrait être utile...
```
new <- sapply( a , grepl , x = names( x1 ) )
names( x1 ) <- b[ apply( new , 1 , which.max ) ]
```
- Depuis, le modèle est trouvé dans les noms de x1, match retourne NA valeurs. grep1 ne fonctionne pas vraiment, aussi, comme il remplace la partie entière de noms plutôt que la partie avec les nombres (comme dans l'édition)
InformationsquelleAutor Simon O'Hanlon
1

Essayer mapply.
```
names(x1) <- mapply(gsub, a, b, names(x1), USE.NAMES = FALSE)
```
Ou, encore plus simple, str_replace de stringr.
```
library(stringr)
names(x1) <- str_replace(names(x1), a, b)
```
- J'ai posté cette réponse ci-dessus déjà, mais ici il n'y a pas besoin de USE.NAMES = FALSE
- Yep, vous me battre pour elle. USE.NAMES = FALSE donne un mineur avantage de performances, pour les grands ensembles de données, peut vous faire économiser presque autant de temps qu'il vous a fallu pour taper les caractères supplémentaires.
- Très vrai sur l'avantage de performances +1
- J'ai essayé str_replace_all de la stringr paquet, qui devrait faire comme décrit. Cependant, il m'a donné un message d'erreur: Erreur dans check_pattern(pattern, string, remplacement) : Longueurs de chaîne et le modèle n'est pas compatible EDIT: j'ai réalisé que str_replace_all exige de les noms(x1) pour être de la même longueur que le a et le b, qui est la raison pourquoi il ne fonctionne pas.
- N'est-ce pas dire que la str_replace solution est fausse? Je pense que oui, mais pas sûr puisque personne n'a soulevé encore.
- Je ne pense pas que mapply œuvres, car il n'est pas récursivement appliquer gsub de noms(x1)
InformationsquelleAutor Richie Cotton

Vous devez vous connecter pour publier un commentaire.