R Academy · पाठ

keep(), discard() और सूची फ़िल्टरिंग

साफ़ pipelines के लिए predicate फ़ंक्शन से सूची तत्व फ़िल्टर करें।

पाठ 4, कुल 4 में से13 चरण

keep(), discard() और सूची फ़िल्टरिंग, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

purrr के साथ सूचियों को फ़िल्टर करना

purrr प्रेडिकेट के आधार पर सूचियों को फ़िल्टर करने, खोजने और जाँचने के लिए फ़ंक्शनों का एक समूह प्रदान करता है। प्रेडिकेट ऐसा फ़ंक्शन है जो TRUE या FALSE लौटाता है। ये फ़ंक्शन लंबे Filter() कॉल और शर्तीय लूप की जगह लेते हैं।

library(purrr)

# A mixed list to filter
mixed <- list(1L, 'hello', 3.14, NULL, TRUE, 42L, 'world', NULL)

cat('Total elements:', length(mixed), '\n')
cat('Non-NULL elements:', length(compact(mixed)))

keep() — प्रेडिकेट से मेल खाने वाले तत्व रखना

keep(.x, .p) केवल .x के उन तत्वों को रखता है जिनके लिए प्रेडिकेट .p TRUE लौटाता है। यह discard() का विपरीत है। प्रेडिकेट फ़ंक्शन का नाम, फ़ॉर्मूला या लॉजिकल वेक्टर हो सकता है।

library(purrr)

mixed <- list(1L, 'hello', 3.14, TRUE, 42L, 'world', 2.7)

# Keep only numeric values
numeric_only <- keep(mixed, is.numeric)
print(numeric_only)

# Keep values greater than 5
keep(mixed, ~is.numeric(.x) && .x > 5)

discard() — प्रेडिकेट से मेल खाने वाले तत्व हटाना

discard(.x, .p) उन तत्वों को हटा देता है जहाँ प्रेडिकेट TRUE लौटाता है और बाकी को रखता है। यह keep() का उलटा कार्य करता है। सूची से NULL, NA या अवांछित प्रकारों को फ़िल्टर करने के लिए इसका उपयोग करें।

library(purrr)

results <- list(
  model_a = list(rmse=2.5, converged=TRUE),
  model_b = list(rmse=NA, converged=FALSE),
  model_c = list(rmse=1.8, converged=TRUE),
  model_d = list(rmse=NA, converged=FALSE)
)

# Discard models that did not converge
converged_models <- discard(results, ~!.x$converged)
map_dbl(converged_models, ~.x$rmse)

compact() — NULL तत्व हटाना

compact(.x) सूची से सभी NULL तत्व हटा देता है — यह discard(.x, is.null) के बराबर है, लेकिन अधिक संक्षिप्त है। यह उन map() कॉल के बाद विशेष रूप से उपयोगी है जो कुछ इनपुट के लिए NULL लौटा सकती हैं।

library(purrr)

# Simulate fetching data that might return NULL
ids <- 1:6
fetch_data <- function(id) {
  if (id %% 2 == 0) NULL else list(id=id, value=id*10)
}

raw_results <- map(ids, fetch_data)
cat('With NULLs:', length(raw_results), '\n')

clean_results <- compact(raw_results)
cat('Without NULLs:', length(clean_results))

detect() — पहला मेल ढूँढना

detect(.x, .p) प्रेडिकेट को संतुष्ट करने वाला पहला तत्व लौटाता है। यदि कोई तत्व मेल नहीं खाता, तो यह NULL लौटाता है। दाएँ से खोजकर अंतिम मेल ढूँढने के लिए detect(.right=TRUE) का उपयोग करें।

library(purrr)

prices <- list(15.99, 8.50, 23.99, 5.25, 19.99, 4.75)

# Find first price under $10
first_cheap <- detect(prices, ~.x < 10)
cat('First price under $10:', first_cheap, '\n')

# Find last price under $10
last_cheap <- detect(prices, ~.x < 10, .right=TRUE)
cat('Last price under $10:', last_cheap)

detect_index() — पहले मेल की स्थिति ढूँढना

detect_index(.x, .p) प्रेडिकेट को संतुष्ट करने वाले पहले तत्व की अनुक्रमणिका लौटाता है (या कुछ न मिलने पर 0L)। यह तब उपयोगी है जब आपको मान नहीं, बल्कि उसकी स्थिति चाहिए — जैसे उस तत्व को अपडेट या निकालने के लिए।

library(purrr)

models <- list(
  list(name='lm', rmse=3.5),
  list(name='rf', rmse=2.1),
  list(name='xgb', rmse=1.8),
  list(name='svm', rmse=2.4)
)

# Find the index of the best model (lowest RMSE)
best_idx <- detect_index(models, function(m) m$rmse < 2.0)
cat('Best model index:', best_idx, '\n')
cat('Best model name:', models[[best_idx]]$name)

every() — क्या सभी तत्व मेल खाते हैं?

every(.x, .p) TRUE लौटाता है यदि प्रेडिकेट प्रत्येक तत्व के लिए संतुष्ट होता है। पहले FALSE पर जाँच रोक देता है। यह all(map_lgl(.x, .p)) के बराबर है, लेकिन इसका मूल्यांकन आलस्यपूर्वक होता है।

library(purrr)

batch_results <- list(
  list(status='success', rows=150),
  list(status='success', rows=200),
  list(status='success', rows=175)
)

failed_batch <- list(
  list(status='success', rows=150),
  list(status='error', rows=0),
  list(status='success', rows=175)
)

cat('All success (good):', every(batch_results, ~.x$status == 'success'), '\n')
cat('All success (bad):', every(failed_batch, ~.x$status == 'success'))

some() — क्या कोई तत्व मेल खाता है?

some(.x, .p) TRUE लौटाता है यदि कम-से-कम एक तत्व प्रेडिकेट को संतुष्ट करता है। पहले TRUE पर जाँच रोक देता है। यह any(map_lgl(.x, .p)) के बराबर है, लेकिन इसका मूल्यांकन आलस्यपूर्वक होता है।

library(purrr)

datasets <- list(
  data.frame(x=1:3, y=c(1,NA,3)),
  data.frame(x=4:6, y=7:9),
  data.frame(x=7:9, y=c(NA,NA,NA))
)

# Does any dataset contain NAs?
cat('Any NAs:', some(datasets, anyNA), '\n')

# Is every dataset NA-free?
cat('All clean:', every(datasets, ~!anyNA(.x)))

none() — क्या कोई भी तत्व मेल नहीं खाता?

none(.x, .p) TRUE लौटाता है यदि कोई भी तत्व प्रेडिकेट को संतुष्ट नहीं करता। यह !some(.x, .p) के बराबर है, लेकिन सत्यापन के संदर्भों में अधिक स्पष्ट पढ़ा जाता है, जहाँ आप किसी शर्त की अनुपस्थिति सुनिश्चित करना चाहते हैं।

library(purrr)

api_responses <- list(
  list(code=200, data='OK'),
  list(code=200, data='OK'),
  list(code=201, data='Created')
)

# Ensure no errors occurred
no_errors <- none(api_responses, ~.x$code >= 400)
cat('No errors:', no_errors, '\n')

# Check another batch
bad_batch <- c(api_responses, list(list(code=500, data='Error')))
none(bad_batch, ~.x$code >= 400)

keep() को map() के साथ संयोजित करना

keep() (या discard()) को map() के साथ श्रृंखलाबद्ध करना एक सामान्य पैटर्न है: पहले सूची को प्रासंगिक तत्वों तक फ़िल्टर करें, फिर रूपांतरण लागू करें। इससे फ़िल्टर करने और संसाधित करने का तर्क स्पष्ट रूप से अलग रहता है।

library(purrr)

model_results <- list(
  list(name='A', converged=TRUE, rmse=2.5),
  list(name='B', converged=FALSE, rmse=NA),
  list(name='C', converged=TRUE, rmse=1.8),
  list(name='D', converged=TRUE, rmse=3.1)
)

# Keep converged, extract RMSE
model_results %>%
  keep(~.x$converged) %>%
  map_dbl(~.x$rmse)

keep() के साथ is.* फ़ंक्शन का उपयोग

R के अंतर्निहित is.* प्रेडिकेट फ़ंक्शन (is.numeric, is.character, is.null, is.na, is.finite) ~ में लपेटे बिना सीधे keep() और discard() में प्रेडिकेट के रूप में काम करते हैं।

library(purrr)

mixed_env <- list(
  count = 42L,
  name = 'Alice',
  ratio = 3.14,
  flag = TRUE,
  missing = NULL,
  data = data.frame(x=1:3)
)

# Extract different types
numeric_items <- keep(mixed_env, is.numeric)
cat('Numeric items:', length(numeric_items), '\n')

# Remove NULL items
cleaned <- discard(mixed_env, is.null)
cat('After removing NULL:', length(cleaned))

त्वरित जाँच

जब .x का कोई भी तत्व प्रेडिकेट .p को संतुष्ट नहीं करता, तब detect(.x, .p) क्या लौटाता है?

पुनरावलोकन: सूची फ़िल्टर करने वाले फ़ंक्शन

purrr के सूची फ़िल्टर करने वाले टूल से जुड़ी मुख्य बातें:

  • keep(.x, .p) — उन तत्वों को रखता है जिनका प्रेडिकेट TRUE हो
  • discard(.x, .p) — उन तत्वों को हटाता है जिनका प्रेडिकेट TRUE हो
  • compact(.x) — सभी NULL तत्वों को हटाता है
  • detect(.x, .p) — प्रेडिकेट से मेल खाने वाला पहला तत्व लौटाता है (या NULL)
  • detect_index(.x, .p) — पहले मेल की अनुक्रमणिका लौटाता है (या 0L)
  • every(.x, .p) — सभी तत्वों के मेल खाने पर TRUE
  • some(.x, .p) — किसी एक तत्व के मेल खाने पर TRUE
  • none(.x, .p) — किसी भी तत्व के मेल न खाने पर TRUE
library(purrr)

scores <- list(45, 72, 88, 53, 91, 67, 39, 85)

passing <- keep(scores, ~.x >= 60)
failing <- discard(scores, ~.x >= 60)

cat('Passing:', length(passing), 'students\n')
cat('Failing:', length(failing), 'students\n')
cat('All pass:', every(scores, ~.x >= 60), '\n')
cat('Any fail:', some(scores, ~.x < 60), '\n')
cat('First pass score:', detect(scores, ~.x >= 60))
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “keep(), discard() और सूची फ़िल्टरिंग” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “keep(), discard() और सूची फ़िल्टरिंग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“keep(), discard() और सूची फ़िल्टरिंग” में मैं क्या सीखूँगा?

साफ़ pipelines के लिए predicate फ़ंक्शन से सूची तत्व फ़िल्टर करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“keep(), discard() और सूची फ़िल्टरिंग” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. map() और टाइपयुक्त रूप
  2. एकाधिक इनपुट के लिए map2() और pmap()
  3. reduce(), accumulate() और walk()
  4. keep(), discard() और सूची फ़िल्टरिंग
← R Academy पर वापस जाएँ