Supprimer les colonnes du bloc de données par nom

J'ai un certain nombre de colonnes que je voudrais supprimer d'un bloc de données. Je sais que nous pouvons les supprimer individuellement en utilisant quelque chose comme:

df$x <- NULL

Mais j'espérais le faire avec moins de commandes.

De plus, je sais que je pourrais supprimer des colonnes en utilisant l'indexation entière comme ceci:

df <- df[ -c(1, 3:6, 12) ]

Mais je crains que la position relative de mes variables ne change.

Étant donné la puissance de R, j'ai pensé qu'il pourrait y avoir un meilleur moyen que de supprimer chaque colonne une par une.

Vous pouvez utiliser une simple liste de noms:

DF <- data.frame(
  x=1:10,
  y=10:1,
  z=rep(5,10),
  a=11:20
)
drops <- c("x","z")
DF[ , !(names(DF) %in% drops)]

Ou, alternativement, vous pouvez faire une liste de ceux à conserver et vous y référer par nom:

keeps <- c("y", "a")
DF[keeps]

EDIT: Pour ceux qui ne connaissent pas encore l' dropargument de la fonction d'indexation, si vous souhaitez conserver une colonne comme trame de données, vous devez:

keeps <- "y"
DF[ , keeps, drop = FALSE]

drop=TRUE(ou ne pas le mentionner) supprimera les dimensions inutiles, et donc retournera un vecteur avec les valeurs de la colonne y.

Il y a aussi la subsetcommande, utile si vous savez quelles colonnes vous voulez:

df <- data.frame(a = 1:10, b = 2:11, c = 3:12)
df <- subset(df, select = c(a, c))

MISE À JOUR après commentaire de @hadley: Pour supprimer les colonnes a, c, vous pouvez faire:

df <- subset(df, select = -c(a, c))

within(df, rm(x))

est probablement le plus simple, ou pour plusieurs variables:

within(df, rm(x, y))

Ou si vous avez affaire à data.tables (par Comment supprimer une colonne par nom dans data.table? ):

dt[, x := NULL]   # Deletes column x by reference instantly.

dt[, !"x"]   # Selects all but x into a new data.table.

ou pour plusieurs variables

dt[, c("x","y") := NULL]

dt[, !c("x", "y")]

Vous pouvez utiliser %in%comme ceci:

df[, !(colnames(df) %in% c("x","bar","foo"))]

list (NULL) fonctionne également:

dat <- mtcars
colnames(dat)
# [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
# [11] "carb"
dat[,c("mpg","cyl","wt")] <- list(NULL)
colnames(dat)
# [1] "disp" "hp"   "drat" "qsec" "vs"   "am"   "gear" "carb"

Si vous souhaitez supprimer les colonnes par référence et éviter la copie interne associée, data.framesvous pouvez utiliser le data.tablepackage et la fonction:=

Vous pouvez passer un nom de vecteur de caractères sur le côté gauche de l' :=opérateur et NULLcomme RHS.

library(data.table)

df <- data.frame(a=1:10, b=1:10, c=1:10, d=1:10)
DT <- data.table(df)
# or more simply  DT <- data.table(a=1:10, b=1:10, c=1:10, d=1:10) #

DT[, c('a','b') := NULL]

Si vous souhaitez prédéfinir les noms en tant que vecteur de caractères en dehors de l'appel à [, encapsulez le nom de l'objet dans ()ou {}pour forcer le LHS à être évalué dans la portée appelante et non en tant que nom dans la portée de DT.

del <- c('a','b')
DT <- data.table(a=1:10, b=1:10, c=1:10, d=1:10)
DT[, (del) := NULL]
DT <-  <- data.table(a=1:10, b=1:10, c=1:10, d=1:10)
DT[, {del} := NULL]
# force or `c` would also work.   

Vous pouvez également utiliser set, ce qui évite la surcharge de [.data.table, et travaille aussi pour data.frames!

df <- data.frame(a=1:10, b=1:10, c=1:10, d=1:10)
DT <- data.table(df)

# drop `a` from df (no copying involved)

set(df, j = 'a', value = NULL)
# drop `b` from DT (no copying involved)
set(DT, j = 'b', value = NULL)

Il existe une stratégie potentiellement plus puissante basée sur le fait que grep () retournera un vecteur numérique. Si vous avez une longue liste de variables comme je le fais dans l'un de mes ensembles de données, certaines variables qui se terminent par ".A" et d'autres qui se terminent par ".B" et vous ne voulez que celles qui se terminent par ".A" (avec avec toutes les variables qui ne correspondent à aucun modèle, procédez comme suit:

dfrm2 <- dfrm[ , -grep("\\.B$", names(dfrm)) ]

Dans le cas présent, en utilisant l'exemple de Joris Meys, ce n'est peut-être pas aussi compact, mais ce serait:

DF <- DF[, -grep( paste("^",drops,"$", sep="", collapse="|"), names(DF) )]

Une autre dplyrréponse. Si vos variables ont une structure de dénomination commune, vous pouvez essayer starts_with(). Par exemple

library(dplyr)
df <- data.frame(var1 = rnorm(5), var2 = rnorm(5), var3 = rnorm (5), 
                 var4 = rnorm(5), char1 = rnorm(5), char2 = rnorm(5))
df
#        var2      char1        var4       var3       char2       var1
#1 -0.4629512 -0.3595079 -0.04763169  0.6398194  0.70996579 0.75879754
#2  0.5489027  0.1572841 -1.65313658 -1.3228020 -1.42785427 0.31168919
#3 -0.1707694 -0.9036500  0.47583030 -0.6636173  0.02116066 0.03983268
df1 <- df %>% select(-starts_with("char"))
df1
#        var2        var4       var3       var1
#1 -0.4629512 -0.04763169  0.6398194 0.75879754
#2  0.5489027 -1.65313658 -1.3228020 0.31168919
#3 -0.1707694  0.47583030 -0.6636173 0.03983268

Si vous souhaitez supprimer une séquence de variables dans le bloc de données, vous pouvez utiliser :. Par exemple, si vous souhaitez supprimer var2, var3et toutes les variables entre les deux, il vous restera simplement var1:

df2 <- df1 %>% select(-c(var2:var3) )  
df2
#        var1
#1 0.75879754
#2 0.31168919
#3 0.03983268

Une autre possibilité:

df <- df[, setdiff(names(df), c("a", "c"))]

ou

df <- df[, grep('^(a|c)$', names(df), invert=TRUE)]

DF <- data.frame(
  x=1:10,
  y=10:1,
  z=rep(5,10),
  a=11:20
)
DF

Production:

    x  y z  a
1   1 10 5 11
2   2  9 5 12
3   3  8 5 13
4   4  7 5 14
5   5  6 5 15
6   6  5 5 16
7   7  4 5 17
8   8  3 5 18
9   9  2 5 19
10 10  1 5 20

DF[c("a","x")] <- list(NULL)

Production:

        y z
    1  10 5
    2   9 5
    3   8 5
    4   7 5
    5   6 5
    6   5 5
    7   4 5
    8   3 5    
    9   2 5
    10  1 5

Solution Dplyr

Je doute que cela obtienne beaucoup d'attention ici, mais si vous avez une liste de colonnes que vous souhaitez supprimer et que vous souhaitez le faire dans une dplyrchaîne que j'utilise one_of()dans la selectclause:

Voici un exemple simple et reproductible:

undesired <- c('mpg', 'cyl', 'hp')

mtcars <- mtcars %>%
  select(-one_of(undesired))

La documentation peut être trouvée en exécutant ?one_ofou ici:

http://genomicsclass.github.io/book/pages/dplyr_tutorial.html

Par intérêt, cela signale l'une des étranges incohérences de syntaxe multiples de R. Par exemple, étant donné un bloc de données à deux colonnes:

df <- data.frame(x=1, y=2)

Cela donne une trame de données

subset(df, select=-y)

mais cela donne un vecteur

df[,-2]

Tout cela est expliqué dans ?[mais ce n'est pas exactement le comportement attendu. Enfin du moins pas pour moi ...

Voici une dplyrfaçon de procéder:

#df[ -c(1,3:6, 12) ]  # original
df.cut <- df %>% select(-col.to.drop.1, -col.to.drop.2, ..., -col.to.drop.6)  # with dplyr::select()

J'aime cela car il est intuitif de lire et de comprendre sans annotation et robuste aux colonnes changeant de position dans le bloc de données. Il suit également l'idiome vectorisé utilisé -pour supprimer des éléments.

Je continue de penser qu'il doit y avoir un meilleur idiome, mais pour la soustraction de colonnes par nom, j'ai tendance à faire ce qui suit:

df <- data.frame(a=1:10, b=1:10, c=1:10, d=1:10)

# return everything except a and c
df <- df[,-match(c("a","c"),names(df))]
df

Il y a une fonction appelée dropNamed()dans le BBmiscpackage de Bernd Bischl qui fait exactement cela.

BBmisc::dropNamed(df, "x")

L'avantage est qu'il évite de répéter l'argument de trame de données et convient donc à la canalisation magrittr(tout comme les dplyrapproches):

df %>% BBmisc::dropNamed("x")

Autre solution si vous ne souhaitez pas utiliser @ hadley ci-dessus: Si "COLUMN_NAME" est le nom de la colonne que vous souhaitez supprimer:

df[,-which(names(df) == "COLUMN_NAME")]

Au-delà de ce qui a été select(-one_of(drop_col_names))démontré dans les réponses précédentes, il existe quelques autres dplyroptions pour supprimer des colonnes select()qui n'impliquent pas la définition de tous les noms de colonnes spécifiques (en utilisant les exemples de données dplyr starwars pour une certaine variété de noms de colonnes):

library(dplyr)
starwars %>% 
  select(-(name:mass)) %>%        # the range of columns from 'name' to 'mass'
  select(-contains('color')) %>%  # any column name that contains 'color'
  select(-starts_with('bi')) %>%  # any column name that starts with 'bi'
  select(-ends_with('er')) %>%    # any column name that ends with 'er'
  select(-matches('^f.+s$')) %>%  # any column name matching the regex pattern
  select_if(~!is.list(.)) %>%     # not by column name but by data type
  head(2)

# A tibble: 2 x 2
homeworld species
  <chr>     <chr>  
1 Tatooine  Human  
2 Tatooine  Droid 

Si vous devez supprimer une colonne qui peut ou peut ne pas exister dans le bloc de données, voici une légère torsion select_if()qui, contrairement à l'utilisation one_of(), ne lancera pas d' Unknown columns:avertissement si le nom de la colonne n'existe pas. Dans cet exemple, 'bad_column' n'est pas une colonne dans le bloc de données:

starwars %>% 
  select_if(!names(.) %in% c('height', 'mass', 'bad_column'))

Fournissez le bloc de données et une chaîne de noms séparés par des virgules à supprimer:

remove_features <- function(df, features) {
  rem_vec <- unlist(strsplit(features, ', '))
  res <- df[,!(names(df) %in% rem_vec)]
  return(res)
}

Utilisation :

remove_features(iris, "Sepal.Length, Petal.Width")

Recherchez l'index des colonnes que vous souhaitez supprimer à l'aide de which. Donnez à ces index un signe négatif ( *-1). Sous-ensemble ensuite sur ces valeurs, ce qui les supprimera de la trame de données. Ceci est un exemple.

DF <- data.frame(one=c('a','b'), two=c('c', 'd'), three=c('e', 'f'), four=c('g', 'h'))
DF
#  one two three four
#1   a   d     f    i
#2   b   e     g    j

DF[which(names(DF) %in% c('two','three')) *-1]
#  one four
#1   a    g
#2   b    h

Si vous avez une grande data.framemémoire et que vous utilisez peu de mémoire [ . . . . ou rmetwithin pour supprimer les colonnes d'undata.frame , comme subsetc'est actuellement le cas (R 3.6.2) en utilisant plus de mémoire - à côté de l'indice du manuel à utiliser de manière subsetinteractive .

getData <- function() {
  n <- 1e7
  set.seed(7)
  data.frame(a = runif(n), b = runif(n), c = runif(n), d = runif(n))
}

DF <- getData()
tt <- sum(.Internal(gc(FALSE, TRUE, TRUE))[13:14])
DF <- DF[setdiff(names(DF), c("a", "c"))] ##
#DF <- DF[!(names(DF) %in% c("a", "c"))] #Alternative
#DF <- DF[-match(c("a","c"),names(DF))]  #Alternative
sum(.Internal(gc(FALSE, FALSE, TRUE))[13:14]) - tt
#0.1 MB are used

DF <- getData()
tt <- sum(.Internal(gc(FALSE, TRUE, TRUE))[13:14])
DF <- subset(DF, select = -c(a, c)) ##
sum(.Internal(gc(FALSE, FALSE, TRUE))[13:14]) - tt
#357 MB are used

DF <- getData()
tt <- sum(.Internal(gc(FALSE, TRUE, TRUE))[13:14])
DF <- within(DF, rm(a, c)) ##
sum(.Internal(gc(FALSE, FALSE, TRUE))[13:14]) - tt
#0.1 MB are used

DF <- getData()
tt <- sum(.Internal(gc(FALSE, TRUE, TRUE))[13:14])
DF[c("a", "c")]  <- NULL ##
sum(.Internal(gc(FALSE, FALSE, TRUE))[13:14]) - tt
#0.1 MB are used