दिलचस्प पोस्ट
खिड़की। विकल्प विकल्प आर में एक वेक्टर के सभी अनूठे एन्यूमरेशन परमिट करें jQuery मान्य आवश्यक चुनें Android फ़ोन में मॉनिटर नेटवर्क गतिविधि पंक्ति में अंतिम नहीं खाली सेल; एक्सेल VBA अप्रत्यक्ष इंतजार का मेल और स्पष्ट रूप से प्रतीक्षा करें अनपेक्षित प्रतीक्षा समय में परिणाम क्यों पायथन 'मेमोरी त्रुटि' सूची में 'ऐप संलग्न () `बहुत सारे RAM बाकी एक्स, वाई का उपयोग करते हुए पिक्सल के माध्यम से GetDIBits और लूप क्या आंतरिक वर्ग निजी चर का उपयोग कर सकते हैं? ओ एक छवि प्रदर्शित जावा में एलबीएएल बनाम ईएएफपी? तैनाती के लिए मेवेन का उपयोग करना शीर्ष पर स्थित यूआईटीबार की स्थिति एक्लिप्स में जावा प्रोजेक्ट: टाइप करें java.lang.Object को हल नहीं किया जा सकता। यह अप्रत्यक्ष रूप से आवश्यक वर्ग वर्गों से संदर्भित है एक निर्माता को अपवाद फेंकने के लिए कब सही है?

एक डेटा का उपयोग करना subsetting! = <कुछ गैर-एनए> भी नहीं भी शामिल है

मेरे पास एक कॉलम है जिसके पास NA एस है I मैं पंक्तियों को छोड़ना चाहता हूं जहां वह स्तंभ एक विशिष्ट मान लेता है (जो "" हो सकता है)। हालांकि, मेरा पहला प्रयास मुझे NA एस के साथ पंक्तियों को भी खो देता है:

 > a = c(1,"",NA) > x <- data.table(a);x a 1: 1 2: 3: NA > y <- x[a!=""];y a 1: 1 

देखने के बाद ?`!=` , मुझे एक एक जहाज मिला जो काम करता है, लेकिन यह एक दर्द है:

 > z <- x[!sapply(a,function(x)identical(x,""))]; z a 1: 1 2: NA 

मैं सोच रहा हूं कि ऐसा करने का एक बेहतर तरीका है? इसके अलावा, मैं इसे कई गैर- NA मानों को छोड़कर इस का विस्तार करने का कोई अच्छा तरीका नहीं देखता हूं। यहां एक बुरा तरीका है:

 > drop_these <- function(these,where){ + argh <- !sapply(where, + function(x)unlist(lapply(as.list(these),function(this)identical(x,this))) + ) + if (is.matrix(argh)){argh <- apply(argh,2,all)} + return(argh) + } > x[drop_these("",a)] a 1: 1 2: NA > x[drop_these(c(1,""),a)] a 1: NA 

मैंने देखा और एक डेटा के साथ चीजों को बाहर करने की कोशिश की। फ्रेम, जो अलग तरीके से काम करते हुए लगता है, एनएएस रखते समय सबसेटिंग:

 > w <- data.frame(a,stringsAsFactors=F); w a 1 1 2 3 <NA> > d <- w[a!="",,drop=F]; d a 1 1 NA <NA> 

Solutions Collecting From Web of "एक डेटा का उपयोग करना subsetting! = <कुछ गैर-एनए> भी नहीं भी शामिल है"

आपके प्रश्न का हल प्रदान करने के लिए:

आपको %in% उपयोग करना चाहिए यह आपको एक तार्किक वेक्टर वापस देता है

 a %in% "" # [1] FALSE TRUE FALSE x[!a %in% ""] # a # 1: 1 # 2: NA 

यह जानने के लिए कि data.table में क्या हो रहा है data.table :

(के रूप में data.frame लिए opposted। data.frame )

यदि आप "[.data.table" फ़ाइल के तहत data.table.R फ़ाइल को data.table.R तो "[.data.table" फ़ाइल के तहत, i arguments के लिए जांच करने वाले "[.data.table" if-statements का एक सेट है उनमें से एक है:

 if (!missing(i)) { # Part (1) isub = substitute(i) # Part (2) if (is.call(isub) && isub[[1L]] == as.name("!")) { notjoin = TRUE if (!missingnomatch) stop("not-join '!' prefix is present on i but nomatch is provided. Please remove nomatch."); nomatch = 0L isub = isub[[2L]] } ..... # "isub" is being evaluated using "eval" to result in a logical vector # Part 3 if (is.logical(i)) { # see DT[NA] thread re recycling of NA logical if (identical(i,NA)) i = NA_integer_ # avoids DT[!is.na(ColA) & !is.na(ColB) & ColA==ColB], just DT[ColA==ColB] else i[is.na(i)] = FALSE } .... } 

विसंगति की व्याख्या करने के लिए, मैंने यहां का महत्वपूर्ण टुकड़ा चिपका लिया है और मैंने उन्हें 3 भागों में भी चिह्नित किया है।

सबसे पहले, क्यों dt[a != ""] ओपी द्वारा अपेक्षित काम नहीं करता?

सबसे पहले, part 1 क्लास call ऑब्जेक्ट का मूल्यांकन करता है। part 2 में अगर कथन का दूसरा भाग गलत हो जाता है उसके बाद, call को "मूल्यांकित" करने के लिए c(TRUE, FALSE, NA) । फिर part 3 निष्पादित है। अतः, NA को FALSE (तार्किक लूप की अंतिम पंक्ति) में बदल दिया गया है।

x[!(a== "")] अपेक्षित काम करता है (ओपी द्वारा)?

part 1 एक बार फिर एक कॉल देता है लेकिन, part 2 मूल्यांकन वास्तविक और इसलिए सेट करता है:

 1) `notjoin = TRUE` 2) isub <- isub[[2L]] # which is equal to (a == "") without the ! (exclamation) 

यही वह जगह है जहां जादू हुआ। अब के लिए अस्वीकृति हटा दी गई है और याद रखना, यह अभी भी कक्षा कॉल का उद्देश्य है। तो यह तर्कसंगत फिर से फिर से मूल्यांकन ( eval का उपयोग) हो जाता है इसलिए, (a=="") c(FALSE, TRUE, NA) मूल्यांकन करता है c(FALSE, TRUE, NA)

अब, इस के लिए जाँच की जाती है। is.logical part 3 । तो, यहां, NA को FALSE बदल दिया जाता है। यह इसलिए हो जाता है, c(FALSE, TRUE, FALSE) । कुछ बिंदु बाद में, एक which(c(F,T,F)) निष्पादित होता है, जो 2 का परिणाम है। क्योंकि notjoin = TRUE ( part 2 ) seq_len(nrow(x))[-2] = c (1,3) वापस आ गया है। इसलिए, x[!(a=="")] मूलतः x[c(1,3)] देता है जो वांछित परिणाम है यहां प्रासंगिक कोड स्निपेट है:

 if (notjoin) { if (bywithoutby || !is.integer(irows) || is.na(nomatch)) stop("Internal error: notjoin but bywithoutby or !integer or nomatch==NA") irows = irows[irows!=0L] # WHERE MAGIC HAPPENS (returns c(1,3)) i = irows = if (length(irows)) seq_len(nrow(x))[-irows] else NULL # NULL meaning all rows ie seq_len(nrow(x)) # Doing this once here, helps speed later when repeatedly subsetting each column. R's [irows] would do this for each # column when irows contains negatives. } 

यह देखते हुए कि, मुझे लगता है कि वाक्यविन्यास के साथ कुछ विसंगतियां हैं .. और अगर मैं समस्या तैयार करने का समय निकालने का प्रबंधन करता हूं, तो मैं जल्द ही एक पोस्ट लिखूंगा

जैसा कि आपने पहले ही सोचा है, यह कारण है:

 a != "" #[1] TRUE NA FALSE 

आप जो पहले से ही समझ चुके हैं, आप ऐसा कर सकते हैं, अर्थात् x[is.na(a) | a != ""] x[is.na(a) | a != ""] या आप a पर setkey कर सकते हैं और निम्न कार्य करें:

 setkey(x, a) x[!J("")] 

मैथ्यू से पृष्ठभूमि का जवाब:

इस सवाल से हाइलाइट किए गए != NA साथ व्यवहार का इरादा नहीं था, इसके बारे में सोच मूल इरादा वास्तव में [.data.frame wrt == और NA से अलग था और मेरा मानना ​​है कि हर कोई इससे खुश है उदाहरण के लिए, अकसर किये गए सवाल 2.17 में है:

DT[ColA==ColB] DF[!is.na(ColA) & !is.na(ColB) & ColA==ColB,] से अधिक आसान है DF[!is.na(ColA) & !is.na(ColB) & ColA==ColB,]

यह सुविधा निम्न के द्वारा प्राप्त की जाती है:

DT[c(TRUE,NA,FALSE)] NA को FALSE रूप में FALSE , लेकिन DF[c(TRUE,NA,FALSE)] प्रत्येक NA लिए NA पंक्तियां देता है

प्रेरणा केवल सुविधा नहीं है, लेकिन प्रत्येक के बाद से गति ! , is.na , & और == खुद वेक्टर स्कैन हैं जो उनके प्रत्येक परिणाम के संबंधित स्मृति आवंटन के साथ स्कैन करते हैं (परिचय संक्षिप्त वर्णन में)। इसलिए हालांकि x[is.na(a) | a!=""] x[is.na(a) | a!=""] एक काम का हल है, यह बिल्कुल तर्क है कि मैं data.table में ज़रूरत से बचने की कोशिश कर रहा था x[!a %in% ""] थोड़ा बेहतर है; यानी, 3 ( is.na , | और != ) की बजाय 2 स्कैन ( %in% और ! ) लेकिन वास्तव में x[a != ""] को एक स्कैन में फ़्रैंक द्वारा अपेक्षित ( NA शामिल करें) करना चाहिए।

इस सुविधा पर वापस लिंक करने वाले नए सुविधा का अनुरोध:

डीटी [कोल! = ""] एनए शामिल होना चाहिए

फ्रैंक, एडडी और अरुण के लिए धन्यवाद अगर मुझे सही ढंग से समझ नहीं आ रहा है तो सही तरीके से सही लग रहा है, अन्यथा परिवर्तन अंततः मिलेगा। यह उस तरीके से किया जाना चाहिए जो मिश्रित अभिव्यक्तियों को समझता है; उदाहरण के लिए, DT[colA=="foo" & colB!="bar"] को colA में NA साथ पंक्तियों को बाहर करना चाहिए, लेकिन पंक्तियां शामिल हों जहां colA गैर- NA लेकिन colB NA । इसी तरह, DT[colA!=colB] में पंक्तियां शामिल होंगी जहां कोला या कॉलब NA लेकिन दोनों नहीं। और शायद DT[colA==colB] में पंक्तियां शामिल colA जहां दोनों colA और colB NA (जो कि फिलहाल मुझे नहीं लगता है)।