दिलचस्प पोस्ट
क्या एसकैपी का उपयोग वेबसाइटों से गतिशील सामग्री को परिमार्जन करने के लिए किया जा सकता है जो AJAX का उपयोग कर रहे हैं? PHP का उपयोग कर SQL सर्वर में स्ट्रिंग कैसे बचें? ड्रॉप-डाउन फाइल को मानक एचटीएमएल फ़ाइल इनपुट में खींचें जावास्क्रिप्ट में सीएसएस पृष्ठभूमि का रंग "इस फ़ाइल प्रकार को संभालने के लिए आपको उपयुक्त लोडर की आवश्यकता हो सकती है" वेबपैक और बैबेल के साथ प्रतिबिंब: मापदंडों के साथ विधि कैसे खोलें स्थितिपट्टी की ऊंचाई? MySQL को सीएसवी आयात करें टेक्स्टफ़ाइल ले जाएं जब कुंजीपटल तेजी से दिखता है ओरेकल एसक्यूएल डेवलपर में दी गई तालिका को किस तालिका में पता लगाया जा सकता है? पीएल / पीजीएसक्यूएल जांच अगर एक पंक्ति मौजूद है बैच फ़ाइल चलाते समय अनिश्चित JProgressBar प्रदर्शित करें जब मैं फ़ंक्शन के अंदर कोई पैरामीटर बदलता हूं, तो क्या यह कॉलर के लिए भी बदलता है? कैसे WPF में pageload पर कॉम्बो बॉक्स में – डिफ़ॉल्ट पाठ "- टीम का चयन करें" प्रदर्शित करने के लिए? ES6 मॉड्यूल: स्थिर तरीकों या एक से अधिक व्यक्तिगत विधियों का एकल वर्ग निर्यात करें

एक डेटा का उपयोग करना 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> 

वेब के समाधान से एकत्रित समाधान "एक डेटा का उपयोग करना 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 (जो कि फिलहाल मुझे नहीं लगता है)।