Upuść kolumny ramki danych według nazwy

Mam wiele kolumn, które chciałbym usunąć z ramki danych. Wiem, że możemy je usuwać indywidualnie za pomocą:

df$x <- NULL

Miałem jednak nadzieję, że zrobię to z mniejszą liczbą poleceń.

Wiem też, że mogłem upuścić kolumny za pomocą indeksowania liczb całkowitych w następujący sposób:

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

Obawiam się jednak, że względne położenie moich zmiennych może ulec zmianie.

Biorąc pod uwagę moc R, pomyślałem, że może być lepszy sposób niż upuszczanie każdej kolumny jedna po drugiej.

Możesz użyć prostej listy nazw:

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)]

Ewentualnie możesz utworzyć listę tych, którzy będą przechowywać, i odwołać się do nich według nazwy:

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

EDYCJA: Jeśli nadal nie dropznasz argumentu funkcji indeksowania, jeśli chcesz zachować jedną kolumnę jako ramkę danych, wykonaj następujące czynności:

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

drop=TRUE(lub nie wspominając o nim) upuści niepotrzebne wymiary, a zatem zwróci wektor z wartościami kolumny y.

Jest też subsetpolecenie przydatne, jeśli wiesz, które kolumny chcesz:

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

AKTUALIZACJA po komentarzu @hadley: Aby upuścić kolumny a, c możesz:

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

within(df, rm(x))

jest prawdopodobnie najłatwiejszy lub dla wielu zmiennych:

within(df, rm(x, y))

Lub jeśli masz do czynienia z data.tables (według Jak usunąć kolumnę według nazwy w data.table? ):

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

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

lub dla wielu zmiennych

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

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

Możesz użyć %in%tego w następujący sposób:

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

lista (NULL) działa również:

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"

Jeśli chcesz usunąć kolumny przez odniesienie i uniknąć powiązanego z nimi wewnętrznego kopiowania data.frames, możesz użyć data.tablepakietu i funkcji:=

Nazwy wektorów znaków możesz przekazać po lewej stronie :=operatora i NULLjako 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]

Jeśli chcesz wstępnie zdefiniować nazwy jako wektor znaków poza wywołaniem [, zawiń nazwę obiektu ()lub {}wymuś, aby LHS był oceniany w zakresie wywołującym, a nie jako nazwa w zakresie 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.   

Możesz także użyć set, co pozwala uniknąć narzutu [.data.table, a także działa 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)

Istnieje potencjalnie silniejsza strategia oparta na fakcie, że grep () zwróci wektor liczbowy. Jeśli masz długą listę zmiennych, tak jak ja, w jednym z moich zbiorów danych, niektóre zmienne, które kończą się na „.A” i inne, które kończą się na „.B”, a chcesz tylko te, które kończą się na „.A” (razem ze wszystkimi zmiennymi, które nie pasują do żadnego wzorca, wykonaj następujące czynności:

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

W omawianym przypadku, na przykładzie Jorisa Meysa, może on nie być tak kompaktowy, ale byłby to:

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

Kolejna dplyrodpowiedź. Jeśli twoje zmienne mają jakąś wspólną strukturę nazewnictwa, możesz spróbować starts_with(). Na przykład

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

Jeśli chcesz upuścić sekwencję zmiennych w ramce danych, możesz użyć :. Na przykład, jeśli chcesz upuścić var2, var3a wszystkie zmienne pomiędzy, będziesz po prostu z var1:

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

Inna możliwość:

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

lub

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

Wynik:

    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)

Wynik:

        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

Rozwiązanie Dplyr

Wątpię, czy to przyniesie wiele uwagi tutaj, ale jeśli masz listę kolumn, które chcesz usunąć i chcesz to zrobić w dplyrłańcuchu, którego używam one_of()w selectklauzuli:

Oto prosty, odtwarzalny przykład:

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

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

Dokumentację można znaleźć, uruchamiając ?one_oflub tutaj:

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

Z braku zainteresowania oznacza to jedną z dziwnych wielokrotnych niespójności składniowych R. Na przykład biorąc pod uwagę dwukolumnową ramkę danych:

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

Daje to ramkę danych

subset(df, select=-y)

ale to daje wektor

df[,-2]

Wszystko to wyjaśniono w, ?[ale nie jest to dokładnie oczekiwane zachowanie. Cóż, przynajmniej nie dla mnie ...

Oto dplyrjak to zrobić:

#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()

Podoba mi się to, ponieważ jest intuicyjny w czytaniu i zrozumieniu bez adnotacji i niezawodny dla kolumn zmieniających położenie w ramce danych. Podąża również za wektoryzowanym idiomem używanym -do usuwania elementów.

Ciągle myślę, że musi istnieć lepszy idiom, ale do odejmowania kolumn według nazwy mam tendencję do wykonywania następujących czynności:

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

W pakiecie dropNamed()Bernda Bischla znajduje się funkcja, BBmiscktóra właśnie to robi.

BBmisc::dropNamed(df, "x")

Zaletą jest to, że unika się powtarzania argumentu ramki danych, a zatem nadaje się do przesyłania strumieniowego magrittr(podobnie jak dplyrpodejścia):

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

Inne rozwiązanie, jeśli nie chcesz używać powyższych @ hadley: Jeśli „COLUMN_NAME” to nazwa kolumny, którą chcesz upuścić:

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

Oprócz select(-one_of(drop_col_names))wcześniejszych odpowiedzi, istnieje kilka innych dplyropcji usuwania kolumn select(), które nie wymagają zdefiniowania wszystkich konkretnych nazw kolumn (użycie przykładowych danych Dplyr Starwars dla różnych odmian nazw kolumn):

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 

Jeśli chcesz upuścić kolumnę, która może istnieć w ramce danych, możesz ją nieco zmienić select_if(), w przeciwieństwie do użyciaone_of() , nie rzuci Unknown columns:ostrzeżenia, jeśli nazwa kolumny nie istnieje. W tym przykładzie „bad_column” nie jest kolumną w ramce danych:

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

Podaj ramkę danych i ciąg nazw oddzielonych przecinkami, aby usunąć:

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

Zastosowanie :

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

Znajdź indeks kolumn, które chcesz upuścić which. Nadaj tym indeksom znak ujemny ( *-1). Następnie podzestaw na te wartości, które usuną je z ramki danych. To jest przykład.

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

Jeśli masz duży data.framei masz mało pamięci [ . . . . lub rmiwithin aby usunąć kolumny zdata.frame , jak subsetjest obecnie (R 3.6.2), wykorzystując więcej pamięci - oprócz wskazówek zawartych w instrukcji, aby używać subsetinteraktywnie .

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