Chute de bloc de données de colonnes par leur nom

J'ai un certain nombre de colonnes que je voudrais enlever 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.

Aussi, je sais que je pourrais déplacer des colonnes à l'aide de entier indexation comme ceci:

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

Mais je crains que la position relative de mes variables peuvent changer.

Compte tenu de la puissance de R, j'ai pensé qu'il pourrait y avoir une meilleure façon que de laisser tomber chaque colonne, un par un.

Quelqu'un peut m'expliquer pourquoi la R n'a pas quelque chose de simple comme df#drop(var_name), et au lieu de cela, nous avons besoin de faire compliqué ces solutions de rechange?
Le " sous-ensemble()' en fonction de R est aussi parcimonieuse que la " goutte()' de la fonction en Python, sauf que vous n'avez pas besoin de spécifier l'axe de l'argumentation... je suis d'accord que c'est ennuyeux qu'il ne peut pas être un seul, l'ultime, le simple mot-clé/syntaxe mis en œuvre à travers le conseil d'administration pour quelque chose d'aussi simple que la suppression d'une colonne.

InformationsquelleAutor Btibert3 | 2011-01-05

dataframe r r-faq

824

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 à garder et se référer à eux par leur nom :
```
keeps <- c("y", "a")
DF[keeps]
```
EDIT :
Pour ceux pas encore familiarisés avec la drop argument de la fonction d'indexation, si vous voulez garder une colonne comme un bloc de données, vous n':
```
keeps <- "y"
DF[ , keeps, drop = FALSE]
```
drop=TRUE (ou de ne pas le mentionner) passera inutile dimensions, et donc le retour d'un vecteur avec les valeurs de la colonne y.
- la fonction de sous-ensemble fonctionne mieux que de ne pas convertir un bloc de données d'une colonne dans un vecteur
- vérifiez l'argument drop=FALSE, la fonction d'indexation.
- Ne pourrait-il pas être DF[,keeps] au lieu de DF[keeps] ?
- Pas de. C'est possible, mais alors vous devez ajouter drop=FALSE pour garder R à partir de la conversion de votre bloc de données à un vecteur si vous ne sélectionnez qu'une seule colonne. N'oubliez pas que les trames de données sont des listes, liste de sélection (à une dimension comme je l'ai fait) fonctionne parfaitement bien et renvoie toujours une liste. Ou d'un bloc de données dans ce cas, c'est pourquoi je préfère l'utiliser.
- wouldnt DF[,garde] de travailler ainsi?
- Oui, il le ferait. Sans virgule, vous utilisez la "liste" de choix, ce qui signifie que même lorsque vous extrayez une seule colonne, vous obtenez toujours une trame de données retournées. Si vous utilisez la "matrice", comme vous le faites, vous devez être conscient que si vous ne sélectionnez qu'une seule colonne, vous obtenez un vecteur lieu d'un bloc de données. Pour éviter cela, vous devez ajouter drop=FALSE. Comme expliqué dans ma réponse, et dans le commentaire juste au-dessus du vôtre...
InformationsquelleAutor Joris Meys
402

Il y a aussi le subset commande, utile si vous connaissez les colonnes que vous souhaitez:
```
df <- data.frame(a = 1:10, b = 2:11, c = 3:12)
df <- subset(df, select = c(a, c))
```
Mis à JOUR après le commentaire de @hadley: Pour baisse les colonnes a,c, vous pouvez faire:
```
df <- subset(df, select = -c(a, c))
```
- Je souhaite vraiment que le R subset fonction a une option comme "allbut = FALSE", qui "inverse" de la sélection lorsque la valeur est TRUE, c'est à dire conserve toutes les colonnes sauf ceux de la select liste.
- voir @joris réponse ci-dessous. Un sous-ensemble sans aucun sous-ensemble de critères est un peu exagérer. Essayez simplement: df[c("a", "c")]
- Je le savais, mais j'aime bien la syntaxe de la commodité de la subset de commande où vous n'avez pas besoin de mettre des guillemets autour des noms de colonnes -- je suppose que je ne me dérange pas de taper quelques caractères supplémentaires juste pour éviter de citer des noms 🙂
- oh, c'est un bon point. Je n'avais pas pensé à l'émission de la soumission.
- Notez que vous ne devriez pas utiliser subset à l'intérieur d'autres fonctions.
- pourquoi pas?
- href="http://stackoverflow.com/questions/12850141/programming-safe-version-of-subset-to-evaluate-its-condition-while-called-from/12852005#12852005" title="programmation de la version safe de sous-ensemble pour évaluer son état et en a appelé de">stackoverflow.com/questions/12850141/...
- Cette select = -b ne semble pas fonctionner?
- b qui fonctionne pour moi
- sous-ensemble(df, sélectionnez = -c(b)) @spacetyper
InformationsquelleAutor Prasad Chalasani
160
```
within(df, rm(x))
```
est probablement la plus facile, ou de plusieurs variables:
```
within(df, rm(x, y))
```
Ou si vous avez affaire à data.tables (par Comment supprimer une colonne par nom dans les données.de la table?):
```
dt[, x := NULL]   # Deletes column x by reference instantly.

dt[, !"x"]   # Selects all but x into a new data.table.
```
ou de plusieurs variables
```
dt[, c("x","y") := NULL]

dt[, !c("x", "y")]
```
- within(df, rm(x)) est loin la solution la plus propre. Étant donné que c'est une possibilité, tous les autres réponse semble inutilement compliqué par un ordre de grandeur.
- Notez que within(df, rm(x)) sera pas travail si il y a double colonnes nommées x dans df.
- pour clarifier, il supprime ni mais semble modifier les données de ses valeurs. On a plus de problèmes si c'est le cas, mais voici un exemple: df <- data.frame(x = 1, y = 2); names(df) <- c("x", "x"); within(df, rm(x)) retourne data.frame(x = 2, x = 2).
- Le problème, c'est que vous comptez sur la fonction within() qui est puissant, mais utilise également NSE. La remarque sur la page d'aide indique clairement que pour la programmation de suffisamment de soin doit être utilisé.
- Comment pouvait-on rencontrer un dataframe avec des doublons de noms?
- Bonjour!
InformationsquelleAutor Max Ghenis
102

Vous pouvez utiliser %in% comme ceci:
```
df[, !(colnames(df) %in% c("x","bar","foo"))]
```
- Ai-je raté quelque chose, ou est-ce effectivement la même solution que la première partie de Joris réponse? DF[ , !(names(DF) %in% drops)]
- c'est la même chose. Regardez la date et l'heure sur les réponses. Nous avons répondu en même temps... il y a 5 ans. 🙂
- De la noisette. identical(post_time_1, post_time_2) [1] TRUE =D
InformationsquelleAutor Joshua Ulrich
44

liste(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"
```
- Génial! Cela s'étend de l'NULLE l'assignation à une seule colonne d'une manière naturelle, et (apparemment) permet d'éviter la copie (bien que je ne sais pas ce qui se passe sous le capot de sorte qu'il peut être plus efficace dans l'utilisation de la mémoire ... mais me semble nettement plus efficace du point de vue syntaxique.)
- Vous n'avez pas besoin de la liste(NULL) (NULL est suffisant. e.g: dat[,4]=NULL
- OP la question est de savoir comment supprimer plusieurs colonnes. dat[,4:5] <- NUL ne fonctionne pas. C'est là que la liste(NULL) vient en. Il fonctionne pour 1 ou plusieurs colonnes.
- Également, cela ne fonctionne pas lorsque vous essayez de supprimer un doublon de nom de colonne.
- Fonctionne très bien pour moi. Soit donner une étiquette si vous souhaitez supprimer le premier des colonnes de même nom ou de donner des indices pour chaque colonne que vous souhaitez supprimer. Si vous avez un exemple de situation où il ne fonctionne pas, je serais intéressé de le voir. Peut-être poster une nouvelle question?
- Cette syntaxe aussi le travail pour data.table ainsi. dat[,c("mpg","cyl","wt")] <- NULL
InformationsquelleAutor Vincent
37

Si vous souhaitez supprimer les colonnes par référence et d'éviter la copie interne associée à data.frames ensuite, vous pouvez utiliser le data.table paquet et la fonction :=

Vous pouvez passer d'un caractère de vecteur de noms à la gauche de la := opérateur, et NULL que le membre de droite.
```
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 de personnages de vecteur à l'extérieur de l'appel à [, enveloppez-le nom de l'objet dans () ou {} à force de GAUCHE à être évalués dans le contexte appelant non pas comme un nom dans le champ d'application 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 fonctionne également pour les 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)
```
InformationsquelleAutor mnel
37

Il est potentiellement plus puissant de la stratégie basée sur le fait que grep() retourne un vecteur numérique. Si vous avez une longue liste de variables comme je le fais dans un de mes jeu de données, certaines variables qui se terminent par ".Un" et d'autres qui se terminent par ".B" et que vous souhaitez seulement ceux qui se terminent par ".Un" (avec toutes les variables qui ne correspondent pas, en soit le motif, ce faire:
```
dfrm2 <- dfrm[ , -grep("\\.B$", names(dfrm)) ]
```
Pour le cas à portée de main, à l'aide de Joris Meys exemple, il pourrait ne pas être aussi compact, mais il serait:
```
DF <- DF[, -grep( paste("^",drops,"$", sep="", collapse="|"), names(DF) )]
```
- Si nous définissons drops en premier lieu comme paste0("^", drop_cols, "$"), cela devient beaucoup plus agréable (lire: plus compact) avec sapply: DF[ , -sapply(drops, grep, names(DF))]
InformationsquelleAutor 42-

Un autre dplyr réponse. Si vos variables ont en commun certaines structure de la nomenclature, vous pouvez essayer de 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 déposer une séquence de variables dans le bloc de données, vous pouvez utiliser :. Par exemple, si vous avez voulu tomber var2, var3, et tous variables entre les deux, vous devriez juste être laissé avec var1:

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

Pour ne pas oublier tous les autres possibilités qui viennent avec select(), comme contains() ou matches(), qui accepte également les regex.

InformationsquelleAutor Pat W.

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

De sortie:

    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)

De sortie:

InformationsquelleAutor Kun Ren

20

D'intérêt, ce drapeaux de l'un de R est bizarre multiples syntaxe des incohérences. Pour l'exemple donné à deux colonnes trame de données:
```
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 est expliqué dans ?[ mais ce n'est pas exactement un comportement attendu. Eh bien au moins, pas pour moi...

InformationsquelleAutor jkeirstead
19

Une autre possibilité:
```
df <- df[, setdiff(names(df), c("a", "c"))]
```
ou
```
df <- df[, grep('^(a|c)$', names(df), invert=TRUE)]
```
- Dommage que ce n'est pas upvoted plus parce que l'utilisation de setdiff est le meilleur en particulier dans le cas d'un très grand nombre de colonnes.
- Sous un autre angle sur cette: df <- df[ , -which(grepl('a|c', names(df)))]
InformationsquelleAutor scentoni
18

Dplyr Solution

Je doute que cela attire beaucoup d'attention ici-bas, mais si vous avez une liste de colonnes que vous souhaitez supprimer, et vous voulez le faire dans un dplyr de la chaîne d'-je utiliser one_of() dans le select clause:

Ici est un simple, reproduit exemple:
```
undesired <- c('mpg', 'cyl', 'hp')

mtcars <- mtcars %>%
  select(-one_of(undesired))
```
Documentation peut être trouvée en exécutant ?one_of ou ici:

http://genomicsclass.github.io/book/pages/dplyr_tutorial.html
- La solution est très compact, mais le dataframe doit être affecté par les changements de réfléchir par exemple mtcars = mtcars %>% sélectionnez(-one_of(indésirable))
- Je suggère l'ajout de Anvita la suggestion de votre solution.
InformationsquelleAutor User632716
17

Ici est un dplyr façon d'aller à ce sujet:
```
#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 parce que c'est de l'intuition à lire & comprendre sans annotation et robuste pour les colonnes de changer de position à l'intérieur de la trame de données. Il suit également les vectorisé idiome à l'aide de - pour supprimer des éléments.
- En ajoutant à ce que (1) l'utilisateur veut remplacer df (2) magrittr a %<>% opérateur de remplacer objet d'entrée pourrait être simplifié pour df %<>% select(-col.to.drop.1, -col.to.drop.2, ..., -col.to.drop.6)
- Si vous avez une longue liste de colonnes de chute, avec dplyr, il pourrait être plus facile de les regrouper et de mettre un seul moins: df.cut <- df %>% select(-c(col.to.drop.1, col.to.drop.2, ..., col.to.drop.n))
InformationsquelleAutor c.gutierrez
13

Je continue à penser que il doit y avoir une meilleure idiome, mais pour la soustraction de colonnes par leur 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
```
- Pas une bonne idée de nier match - df[,-match(c("e","f"),names(df))]
- .@JDLong - Ce que si je souhaite supprimer une colonne où le nom de la colonne commence par -?
InformationsquelleAutor JD Long
11

Il y a une fonction appelée dropNamed() de Bernd Bischl de BBmisc package qui fait exactement cela.
```
BBmisc::dropNamed(df, "x")
```
L'avantage est qu'il évite de répéter le bloc de données de l'argument et est donc adapté pour la tuyauterie dans magrittr (tout comme le dplyr approches):
```
df %>% BBmisc::dropNamed("x")
```
InformationsquelleAutor krlmlr
7

Une autre solution si vous ne souhaitez pas utiliser @hadley est ci-dessus: Si "COLUMN_NAME" est le nom de la colonne que vous voulez supprimer:
```
df[,-which(names(df) == "COLUMN_NAME")]
```
- (1) le Problème est d'abandonner plusieurs colonnes à la fois. (2) Il ne fonctionnera pas si COLUMN_NAME n'est pas dans df (vérifiez vous-même: df<-data.frame(a=1,b=2)). (3) df[,names(df) != "COLUMN_NAME"] est plus simple et n'en souffrent pas (2)
- Pouvez-vous donner plus d'informations à propos de cette réponse?
InformationsquelleAutor Nick Keramaris

Au-delà de select(-one_of(drop_col_names)) démontré dans les réponses précédentes, il ya un couple d'autres dplyr options pour la suppression de colonnes à l'aide de select() qui n'impliquent pas la définition de tous les noms de colonne (à l'aide de la dplyr starwars données de l'échantillon pour un peu de variété dans les noms de colonne):

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

InformationsquelleAutor sbha

Fournir les bloc de données et une chaîne de séparés par des virgules de noms à 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")

Chute de bloc de données de colonnes par leur nom

InformationsquelleAutor Cybernetic

Trouver l'index de colonnes que vous voulez déposer à l'aide de which. Donner à ces indices d'un signe négatif (*-1). Puis sous-ensemble sur ces valeurs, ce qui permettra de les retirer de la dataframe. C'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

InformationsquelleAutor milan

Vous devez vous connecter pour publier un commentaire.