R: Remplacer les multiples valeurs de plusieurs colonnes de dataframes avec NA

Je suis en train de réaliser quelque chose de similaire à cette question mais avec plusieurs valeurs qui doivent être remplacés par de NA, et dans le grand jeu de données.

df <- data.frame(name = rep(letters[1:3], each = 3), foo=rep(1:9),var1 = rep(1:9), var2 = rep(3:5, each = 3))

qui génère cette dataframe:

df
  name foo var1 var2
1    a   1    1    3
2    a   2    2    3
3    a   3    3    3
4    b   4    4    4
5    b   5    5    4
6    b   6    6    4
7    c   7    7    5
8    c   8    8    5
9    c   9    9    5

Je voudrais remplacer toutes les occurrences de, disons, 3 et 4 par NA, mais seulement dans les colonnes qui commencent par "var".

Je sais que je peux utiliser une combinaison de [] opérateurs pour obtenir le résultat que je veux:

df[,grep("^var[:alnum:]?",colnames(df))][ 
        df[,grep("^var[:alnum:]?",colnames(df))] == 3 |
        df[,grep("^var[:alnum:]?",colnames(df))] == 4
   ] <- NA

df
  name foo var1 var2
1    a   1    1    NA
2    a   2    2    NA
3    a   3    NA   NA
4    b   4    NA   NA
5    b   5    5    NA
6    b   6    6    NA
7    c   7    7    5
8    c   8    8    5
9    c   9    9    5

Maintenant mes questions sont les suivantes:

Est-il un moyen de le faire de manière efficace, étant donné que mon réel
jeu de données d'environ 100.000 lignes, et de 400 à 500 variables commencent
avec "var". Il me semble (subjectivement) lent sur mon ordinateur lorsque j'utilise
les deux crochets de la technique.
Comment pourrais-je aborder le problème si
au lieu de 2 valeurs (3 et 4) pour être remplacé par NA, j'ai eu une longue
liste de, disons, 100 valeurs différentes? Est-il un moyen de spécifier plusieurs valeurs avec le fait de devoir faire un maladroit série de conditions séparés par | opérateur?

Vous pouvez utiliser %in%.

OriginalL'auteur Peutch | 2014-09-10

dataframe multiple-columns r replace

12

Vous pouvez également le faire à l'aide de replace:
```
sel <- grepl("var",names(df))
df[sel] <- lapply(df[sel], function(x) replace(x,x %in% 3:4, NA) )
df

#  name foo var1 var2
#1    a   1    1   NA
#2    a   2    2   NA
#3    a   3   NA   NA
#4    b   4   NA   NA
#5    b   5    5   NA
#6    b   6    6   NA
#7    c   7    7    5
#8    c   8    8    5
#9    c   9    9    5
```
Rapide analyse comparative à l'aide d'un million de lignes de l'échantillon de données suggère que c'est plus rapide que les autres réponses.

+1 Pourriez-vous poster les benchmarks? Merci.
Sur mes données, je suis allé à partir de 17 secondes à 1,8 secondes, une dizaine de fois en baisse par rapport à @akrun méthode! Merci!
J'ai ajouté des critères de référence à ma réponse.
Aucune idée si c'est possible de compter le nombre de valeurs ont été modifiées?

OriginalL'auteur thelatemail

Vous pouvez aussi faire:

col_idx <- grep("^var", names(df))
values <- c(3, 4)
m1 <- as.matrix(df[,col_idx])
m1[m1 %in% values] <- NA
df[col_idx]  <- m1
df
#   name foo var1 var2
#1    a   1    1   NA
#2    a   2    2   NA
#3    a   3   NA   NA
#4    b   4   NA   NA
#5    b   5    5   NA
#6    b   6    6   NA
#7    c   7    7    5
#8    c   8    8    5
#9    c   9    9    5

Je vous remercie. Avec mes données, cette solution s'avère être de 6 ou 7 fois plus rapide que la sapply méthode.
Je pense que j'ai pressé une fraction plus de vitesse de ce avec replace - pourriez-vous tester sur vos données?

OriginalL'auteur akrun

~~je n'ai pas chronométré cette option, mais~~ j'ai écrit une fonction appelée makemeNA qui fait partie de mon GitHub seulement "SOfun" package.

Avec cette fonction, l'approche serait quelque chose comme ceci:

library(SOfun)

Cols <- grep("^var", names(df))
df[Cols] <- makemeNA(df[Cols], NAStrings = as.character(c(3, 4)))
df
#   name foo var1 var2
# 1    a   1    1   NA
# 2    a   2    2   NA
# 3    a   3   NA   NA
# 4    b   4   NA   NA
# 5    b   5    5   NA
# 6    b   6    6   NA
# 7    c   7    7    5
# 8    c   8    8    5
# 9    c   9    9    5

La fonction utilise la na.strings argument en type.convert de faire la conversion en NA.

Installer le package avec:

library(devtools)
install_github("SOfun", "mrdwab")

(ou de votre méthode préférée de l'installation des packages à partir de GitHub).

Voici une partie de l'analyse comparative. J'ai décidé de rendre les choses intéressantes et de remplacer à la fois numériques et non-valeurs numériques avec NA pour voir comment les choses se comparer.

Voici les données de l'échantillon:

n <- 1000000
set.seed(1)
df <- data.frame(
  name1 = sample(letters[1:3], n, TRUE), 
  name2 = sample(letters[1:3], n, TRUE),
  name3 = sample(letters[1:3], n, TRUE),
  var1 = sample(9, n, TRUE), 
  var2 = sample(5, n, TRUE),
  var3 = sample(9, n, TRUE))

Voici les fonctions de test:

fun1 <- function() {
  Cols <- names(df)
  df[Cols] <- makemeNA(df[Cols], NAStrings = as.character(c(3, 4, "a")))
  df
}

fun2 <- function() {
  values <- c(3, 4, "a")
  col_idx <- names(df)
  m1 <- as.matrix(df)
  m1[m1 %in% values] <- NA
  df[col_idx]  <- m1
  df
}

fun3 <- function() {
  values <- c(3, 4, "a")
  col_idx <- names(df)
  val_idx <- sapply(df[col_idx], "%in%", table = values)
  is.na(df[col_idx]) <- val_idx
  df
}

fun4 <- function() {
  sel <- names(df)
  df[sel] <- lapply(df[sel], function(x) 
    replace(x, x %in% c(3, 4, "a"), NA))
  df
}

Je suis en rupture de sortir fun2 et fun3. Je ne suis pas fou au sujet de fun2, car il convertit tout de même type. J'attends aussi de fun3 plus lente.

system.time(fun2())
#    user  system elapsed 
#    4.45    0.33    4.81 

system.time(fun3())
#    user  system elapsed 
#   34.31    0.38   34.74

Alors maintenant, il vient vers moi et Thela...

library(microbenchmark)
microbenchmark(fun1(), fun4(), times = 50)
# Unit: seconds
#    expr      min       lq   median       uq      max neval
#  fun1() 2.934278 2.982292 3.070784 3.091579 3.617902    50
#  fun4() 2.839901 2.964274 2.981248 3.128327 3.930542    50

Dang vous Thela!

+1 je me suis converti à la matrice comme le montre l'exemple numeric colonnes pour comparer

OriginalL'auteur A5C1D2H2I1M1N2O1R2T1

Voici une approche:

# the values that should be replaced by NA
values <- c(3, 4)

# index of columns
col_idx <- grep("^var", names(df))
# [1] 3 4

# index of values (within these columns)
val_idx <- sapply(df[col_idx], "%in%", table = values)
#        var1  var2
#  [1,] FALSE  TRUE
#  [2,] FALSE  TRUE
#  [3,]  TRUE  TRUE
#  [4,]  TRUE  TRUE
#  [5,] FALSE  TRUE
#  [6,] FALSE  TRUE
#  [7,] FALSE FALSE
#  [8,] FALSE FALSE
#  [9,] FALSE FALSE

# replace with NA
is.na(df[col_idx]) <- val_idx

df
#   name foo var1 var2
# 1    a   1    1   NA
# 2    a   2    2   NA
# 3    a   3   NA   NA
# 4    b   4   NA   NA
# 5    b   5    5   NA
# 6    b   6    6   NA
# 7    c   7    7    5
# 8    c   8    8    5
# 9    c   9    9    5

OriginalL'auteur Sven Hohenstein

Ici est un dplyr solution:

# Define replace function
repl.f <- function(x) ifelse(x%in%c(3,4), NA,x)

library(dplyr)
cbind(select(df, -starts_with("var")),
  mutate_each(select(df, starts_with("var")), funs(repl.f)))

  name foo var1 var2
1    a   1    1   NA
2    a   2    2   NA
3    a   3   NA   NA
4    b   4   NA   NA
5    b   5    5   NA
6    b   6    6   NA
7    c   7    7    5
8    c   8    8    5
9    c   9    9    5

OriginalL'auteur Tomiris

Vous devez vous connecter pour publier un commentaire.