नाम से डेटा फ़्रेम कॉलम ड्रॉप करें

Question

मेरे पास कई कॉलम हैं जिन्हें मैं डेटा फ्रेम से हटाना चाहूंगा। मुझे पता है कि हम कुछ का उपयोग करके उन्हें व्यक्तिगत रूप से हटा सकते हैं:

df$x <- NULL

लेकिन मैं कम आदेशों के साथ ऐसा करने की उम्मीद कर रहा था।

इसके अलावा, मुझे पता है कि मैं इस तरह पूर्णांक अनुक्रमण का उपयोग करके कॉलम को छोड़ सकता हूं:

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

लेकिन मुझे चिंता है कि मेरे चर की सापेक्ष स्थिति बदल सकती है।

यह देखते हुए कि आर कितना शक्तिशाली है, मुझे लगा कि प्रत्येक कॉलम को एक-एक करके छोड़ने से बेहतर तरीका हो सकता है।

Comments

क्या कोई मुझे समझा सकता है कि आर के पास कुछ सरल क्यों नहीं है df#drop(var_name), और इसके बजाय, हमें इन जटिल कामों को करने की आवश्यकता है?

— ifly6

@ ifly6 R में 'सब्मिट ()' फंक्शन, पायथन में 'ड्रॉप ()' फंक्शन के रूप में पार्सिमेनस के बारे में है, सिवाय इसके कि आपको अक्ष तर्क को निर्दिष्ट करने की आवश्यकता नहीं है ... मैं मानता हूं कि यह कष्टप्रद है कि वहाँ नहीं हो सकता एक कॉलम को छोड़ने जैसे कुछ बुनियादी के लिए बोर्ड में लागू किया गया सिर्फ एक, अंतिम, आसान कीवर्ड / वाक्यविन्यास हो।

— पॉल सुचक्की

Answer 1

आप नामों की एक सरल सूची का उपयोग कर सकते हैं:

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

या, वैकल्पिक रूप से, आप उन लोगों की एक सूची बना सकते हैं जो उन्हें नाम से रखना और संदर्भित करना चाहते हैं:

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

EDIT: उन लोगों के लिए जो अभी भी dropअनुक्रमण फ़ंक्शन के तर्क से परिचित नहीं हैं , यदि आप एक कॉलम को डेटा फ़्रेम के रूप में रखना चाहते हैं, तो आप निम्न कार्य करते हैं:

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

drop=TRUE(या इसका उल्लेख नहीं) अनावश्यक आयामों को छोड़ देगा, और इसलिए स्तंभ के मानों के साथ एक वेक्टर लौटाएगा y।

Comments

सबसेट फ़ंक्शन बेहतर काम करता है क्योंकि यह डेटा कॉलम को वेक्टर में परिवर्तित नहीं करेगा

— mut1na

@ mut1na तर्क ड्रॉप की जाँच करें = अनुक्रमणिका फ़ंक्शन का FALSE।

— जोरिस मेय्स

DF[,keeps]इसके बजाय नहीं होना चाहिए DF[keeps]?

— लिंडेलोफ

@lindelof No. यह हो सकता है, लेकिन यदि आप केवल एक कॉलम का चयन करते हैं तो आपको अपने डेटा फ्रेम को वेक्टर में कनवर्ट करने से R रखने के लिए ड्रॉप = FALSE जोड़ना होगा। , कि डेटा फ्रेम सूची नहीं है भूल जाते हैं तो सूची चयन (एक आयामी तरह मैंने किया था) पूरी तरह से अच्छी तरह से काम करता है और हमेशा एक सूची लौटाती है। या इस मामले में एक डेटा फ्रेम, यही वजह है कि मैं इसका उपयोग करना पसंद करता हूं।

— जोरिस मेस

@ अजय ओहरी, यह होगा। अल्पविराम के बिना, आप चयन करने के "सूची" तरीके का उपयोग करते हैं, जिसका अर्थ है कि जब आप एकल कॉलम निकालते हैं, तब भी आपको डेटा फ़्रेम वापस मिल जाता है। यदि आप "मैट्रिक्स" तरीके का उपयोग करते हैं, जैसा कि आप करते हैं, तो आपको पता होना चाहिए कि यदि आप केवल एक कॉलम का चयन करते हैं, तो आपको डेटा फ़्रेम के बजाय एक वेक्टर मिलता है। उससे बचने के लिए, आपको ड्रॉप = FALSE जोड़ना होगा। जैसा कि मेरे उत्तर में बताया गया है, और आपके ठीक ऊपर की टिप्पणी में ...

— जोरिस मेय्स

Answer 2

subsetयदि आप जानते हैं कि आपको कौन-से कॉलम चाहिए, यह भी कमांड, उपयोगी है:

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

@Hadley की टिप्पणी के बाद अपडेट किया गया: कॉलम a, c को आप करने के लिए छोड़ सकते हैं:

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

Comments

मैं वास्तव में चाहते हैं आर subsetसमारोह की तरह "allbut = FALSE" है, जो "उलट" चयन जब सेट सही पर, यानी सभी स्तंभों को बरकरार रखे हुए एक विकल्प था सिवाय उन लोगों selectकी सूची।

— प्रसाद चालसानी

@प्रसाद, नीचे @joris जवाब देखें। किसी भी उप-मापदंड के बिना एक सबसेट ओवरकिल का एक सा है। बस कोशिश करें:df[c("a", "c")]

— JD लॉन्ग

@JD मुझे पता था कि, लेकिन मुझे subsetकमांड की सिंटैक्टिक सुविधा पसंद है जहां आपको कॉलम नामों के आसपास उद्धरण देने की आवश्यकता नहीं है - मुझे लगता है कि मुझे कुछ अतिरिक्त अक्षर टाइप करने में कोई दिक्कत नहीं है, केवल नाम उद्धृत करने से बचने के लिए :)

— प्रसाद चालसानी

ध्यान दें कि आपको subsetअन्य कार्यों के अंदर उपयोग नहीं करना चाहिए ।

— अरी बी। फ्रीडमैन

@mac stackoverflow.com/questions/12850141/...

— अरी बी फ्राइडमैन

Answer 3

within(df, rm(x))

शायद सबसे आसान है, या कई चर के लिए:

within(df, rm(x, y))

या यदि आप data.tableएस के साथ काम कर रहे हैं (प्रति के रूप में आप डेटा में नाम से एक कॉलम को कैसे हटा सकते हैं? ):

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

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

या कई चर के लिए

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

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

Comments

within(df, rm(x))है अब तक का सबसे स्वच्छ समाधान। यह देखते हुए कि यह एक संभावना है, हर दूसरा उत्तर परिमाण के एक क्रम से अनावश्यक रूप से जटिल लगता है।

— माइल्स एरिकसन

ध्यान दें कि within(df, rm(x))होगा नहीं अगर वहाँ डुप्लिकेट कॉलम नामित कर रहे हैं काम xमें df।

— माइकलचिरिको

@MichaelChirico स्पष्ट करने के लिए, यह न तो हटाता है, बल्कि डेटा के मूल्यों को बदलता है। यदि यह मामला है, तो एक बड़ी समस्या है, लेकिन यहां एक उदाहरण है: df <- data.frame(x = 1, y = 2); names(df) <- c("x", "x"); within(df, rm(x))रिटर्न data.frame(x = 2, x = 2)।

— मैक्स गनीस

@MilesErickson समस्या यह है कि आप एक ऐसे फ़ंक्शन पर भरोसा करते हैं within()जो शक्तिशाली है लेकिन एनएसई का उपयोग भी करता है। मदद पृष्ठ पर नोट में स्पष्ट रूप से लिखा गया है कि प्रोग्रामिंग के लिए पर्याप्त देखभाल का उपयोग किया जाना चाहिए।

— जॉरिस मेस

@ मील्सइरिकसन कितनी बार एक डुप्लिकेट नाम के साथ डेटाफ्रेम का सामना करेगा?

— एचएसचमले

Answer 4

आप %in%इस तरह का उपयोग कर सकते हैं :

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

Comments

मैं कुछ इस प्रभावी ढंग से जोरिस 'जवाब के पहले भाग के रूप में ही समाधान याद आ रही है, या है? DF[ , !(names(DF) %in% drops)]

— डैनियल फ्लेचर

@ डैनियल फ्लेचर: यह एक ही है। जवाब पर टाइमस्टैम्प को देखें। हमने उसी समय उत्तर दिया ... 5 साल पहले। :)

— जोशुआ उलरिच

नटी। identical(post_time_1, post_time_2) [1] TRUE = डी

— डैनियल फ्लेचर

Answer 5

सूची (NULL) भी काम करती है:

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"

Comments

प्रतिभाशाली! यह NULL असाइनमेंट को एक प्राकृतिक तरीके से एक एकल कॉलम तक बढ़ाता है, और (प्रतीत होता है) कॉपी करने से बचता है (हालांकि मुझे नहीं पता कि हुड के नीचे क्या होता है इसलिए यह मेमोरी उपयोग में अधिक कुशल नहीं हो सकता है ... लेकिन मुझे स्पष्ट रूप से लगता है अधिक कुशल वाक्यविन्यास।)

— सी-यूरिन

आपको सूची (NULL) की आवश्यकता नहीं है, NULL पर्याप्त है। उदाहरण के लिए: Dat [4] = शून्य

— CousinCocaine

ओपी का सवाल था कि कई कॉलम कैसे हटाए जाएं। Dat [, 4: 5] <- शून्य काम नहीं करेगा। वहीं सूची (शून्य) में आता है। यह 1 या अधिक स्तंभों के लिए काम करता है।

— विंसेंट

डुप्लिकेटेड कॉलम नाम को हटाने की कोशिश करने पर यह भी काम नहीं करता है।

— माइकल किरिको 19

@MichaelChirico मेरे लिए ठीक काम करता है। या तो एक लेबल दें यदि आप एक ही नाम के साथ कॉलम को हटाना चाहते हैं या प्रत्येक कॉलम को हटाना चाहते हैं। यदि आपके पास एक उदाहरण है जहां यह काम नहीं करता है तो मैं इसे देखना चाहूंगा। शायद इसे एक नए प्रश्न के रूप में पोस्ट करें?

— विंसेंट

Answer 6

यदि आप संदर्भ द्वारा कॉलम को हटाना चाहते हैं और इससे जुड़ी आंतरिक नकल से बचते हैं data.framesतो आप data.tableपैकेज और फ़ंक्शन का उपयोग कर सकते हैं:=

आप :=ऑपरेटर के बाएं हाथ की ओर , और NULLRHS के रूप में एक चरित्र वेक्टर नाम पास कर सकते हैं ।

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]

आप के लिए कॉल बाहर चरित्र वेक्टर के रूप में के रूप में नाम पूर्वपरिभाषित चाहते हैं [, में ऑब्जेक्ट का नाम लपेट ()या {}मजबूर करने के लिए एलएचएस बुला दायरे में मूल्यांकन किया जाना के दायरे के भीतर एक नाम के रूप में नहीं 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.   

आप भी उपयोग कर सकते हैं set, जो ओवरहेड से बचा जाता है [.data.table, और इसके लिए भी काम करता है 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)

Answer 7

इस तथ्य के आधार पर संभावित रूप से अधिक शक्तिशाली रणनीति है कि grep () एक संख्यात्मक वेक्टर लौटाएगा। यदि आपके पास मेरे एक डेटासेट में वैरिएबल की लंबी सूची है, तो कुछ वैरिएबल्स जो ".A" में समाप्त होते हैं और अन्य जो ".B" में समाप्त होते हैं और आप केवल वही चाहते हैं जो "। ए" में समाप्त होते हैं (साथ में) सभी चर जो पैटर्न से मेल नहीं खाते, ऐसा करें:

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

हाथ में मामले के लिए, जोरिस मेस उदाहरण का उपयोग करते हुए, यह कॉम्पैक्ट के रूप में नहीं हो सकता है, लेकिन यह होगा:

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

Comments

यदि हम परिभाषित dropsके रूप में पहली जगह में paste0("^", drop_cols, "$")साथ:, यह बहुत अच्छा (अधिक कॉम्पैक्ट पढ़ें) हो जाता है sapply:DF[ , -sapply(drops, grep, names(DF))]

— MichaelChirico

Answer 8

एक अन्य dplyrसवाल का जवाब। यदि आपके चर में कुछ सामान्य नामकरण संरचना है, तो आप कोशिश कर सकते हैं starts_with()। उदाहरण के लिए

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

आप डेटा फ्रेम में चर का एक अनुक्रम ड्रॉप करना चाहते हैं, तो आप उपयोग कर सकते हैं :। उदाहरण के लिए यदि आप ड्रॉप करना चाहता था var2, var3और सभी के बीच में चर, तुम बस के साथ नहीं छोड़ा जा सकता था var1:

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

Comments

नहीं सभी अन्य अवसरों के साथ आते हैं के बारे में भूल करने के लिए select()इस तरह के रूप में, contains()या matches()है, जो भी regex स्वीकार करता है।

— ha_pu

Answer 9

एक अन्य संभावना:

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

या

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

Comments

बहुत बुरा है कि इसे अधिक नहीं उतारा गया है क्योंकि इसका उपयोग setdiffविशेष रूप से बहुत बड़ी संख्या में स्तंभों के मामले में इष्टतम है।

— ctbrown

इस पर एक और कोण:df <- df[ , -which(grepl('a|c', names(df)))]

— जो

Answer 10

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

आउटपुट:

    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)

आउटपुट:

        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

Answer 11

डसलर सॉल्यूशन

मुझे संदेह है कि यहाँ बहुत ध्यान दिया जाएगा, लेकिन अगर आपके पास उन स्तंभों की एक सूची है, जिन्हें आप हटाना चाहते हैं, और आप इसे उस dplyrश्रृंखला में करना चाहते हैं जिसका मैं खंड one_of()में उपयोग करता हूं select:

यहाँ एक सरल, प्रतिलिपि प्रस्तुत करने योग्य उदाहरण है:

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

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

दस्तावेज़ीकरण को ?one_ofयहां या यहां चलाकर पाया जा सकता है:

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

Answer 12

ब्याज में से, आर के अजीब कई वाक्य रचना विसंगतियों में से एक इस झंडे। उदाहरण के लिए दिए गए एक दो-स्तंभ डेटा फ्रेम:

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

यह एक डेटा फ्रेम देता है

subset(df, select=-y)

लेकिन यह एक वेक्टर देता है

df[,-2]

यह सब समझाया गया है, ?[लेकिन यह बिल्कुल अपेक्षित व्यवहार नहीं है। खैर, कम से कम मेरे लिए तो नहीं...

Answer 13

यहाँ dplyrइसके बारे में जाने का एक तरीका है:

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

मुझे यह पसंद है क्योंकि यह एनोटेशन के बिना पढ़ने और समझने के लिए सहज है और डेटा फ्रेम के भीतर कॉलम बदलने की स्थिति के लिए मजबूत है। -तत्वों को हटाने के लिए यह वेक्टरयुक्त मुहावरे का भी अनुसरण करता है ।

Comments

इसमें जोड़ा जा रहा है कि (1) उपयोगकर्ता मूल df (2) को प्रतिस्थापित करना चाहते हैं, मैग्रीटर के पास %<>% इनपुट ऑब्जेक्ट को बदलने के लिए ऑपरेटर है जिसे इसे सरल बनाया जा सकता हैdf %<>% select(-col.to.drop.1, -col.to.drop.2, ..., -col.to.drop.6)

— Marek

यदि आपके पास स्तंभों की एक लंबी सूची है dplyr, तो, उन्हें समूह में रखना आसान हो सकता है और केवल एक ऋण दिया जा सकता है:df.cut <- df %>% select(-c(col.to.drop.1, col.to.drop.2, ..., col.to.drop.n))

— iNyar

Answer 14

मुझे लगता है कि एक बेहतर मुहावरा होना चाहिए, लेकिन नाम से स्तंभों के घटाव के लिए, मैं निम्नलिखित काम करता हूं:

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

Comments

मैच को नकारने के लिए एक अच्छा विचार नहीं है -df[,-match(c("e","f"),names(df))]

— हेडली

। @ JDLong - क्या होगा यदि मैं कॉलम को छोड़ना चाहता हूं जहां कॉलम नाम के साथ शुरू होता है -?

— चेतन अरविंद पाटिल

Answer 15

एक समारोह है जिसे dropNamed()बर्नड बस्च्ल के BBmiscपैकेज में कहा जाता है जो वास्तव में ऐसा करता है।

BBmisc::dropNamed(df, "x")

लाभ यह है कि डेटा फ्रेम तर्क दोहरा से बचा जाता है और इस प्रकार में पाइप के लिए उपयुक्त है है magrittr(जैसे dplyrदृष्टिकोण):

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

Answer 16

यदि आप @ हैडली के ऊपर का उपयोग नहीं करना चाहते हैं तो एक और उपाय: यदि "COLUMN_NAME" उस स्तंभ का नाम है जिसे आप छोड़ना चाहते हैं:

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

Comments

(1) समस्या एक साथ कई कॉलम गिराने की है। (2) यह काम नहीं करेगा यदि COLUMN_NAMEवह dfस्वयं नहीं है (स्वयं की जाँच करें:) df<-data.frame(a=1,b=2)। (3) df[,names(df) != "COLUMN_NAME"]सरल है और (2) से ग्रस्त नहीं है

— मारेक

क्या आप इस उत्तर के बारे में कुछ और जानकारी दे सकते हैं?

— आकाश नायक

Answer 17

select(-one_of(drop_col_names))पहले के उत्तर में प्रदर्शित होने के अलावा , dplyrस्तंभों को छोड़ने के लिए कुछ अन्य विकल्प select()हैं, जिसमें सभी विशिष्ट स्तंभ नामों को परिभाषित करना शामिल नहीं है (स्तंभ नाम में कुछ विविधता के लिए dplyr starwars नमूना डेटा का उपयोग करके):

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 

आप एक स्तंभ या डेटा फ्रेम में मौजूद नहीं हो सकता है ड्रॉप करने की जरूरत है, यहाँ का उपयोग कर एक मामूली मोड़ है select_if()कि विपरीत का उपयोग कर one_of()एक फेंक नहीं होगा Unknown columns:चेतावनी यदि स्तंभ नाम करता है मौजूद नहीं। इस उदाहरण में 'bad_column' डेटा फ्रेम में एक कॉलम नहीं है:

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

Answer 18

हटाने के लिए डेटा फ़्रेम और अल्पविराम से अलग नामों की एक स्ट्रिंग प्रदान करें :

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

उपयोग :

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

Answer 19

उन स्तंभों के सूचकांक का पता लगाएं, जिनका आप उपयोग करना चाहते हैं which। इन अनुक्रमों को एक नकारात्मक चिह्न ( *-1) दें। फिर उन मूल्यों पर सब्मिट करें, जो उन्हें डेटाफ्रेम से निकाल देंगे। यह एक उदाहरण है।

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

Answer 20

आप एक बड़े है data.frameऔर स्मृति उपयोग पर कम कर रहे हैं [ । । । । या rmऔरwithin करने के लिए एक के स्तंभों को निकालनेdata.frame , के रूप में subsetवर्तमान में (नि 3.6.2) और अधिक स्मृति का उपयोग है - बगल में मैनुअल के संकेत करने के लिए उपयोग करने के subsetसहभागी ।

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