Dplyr: शून्य-लंबाई वाले समूहों को संरक्षित करें

इस मुद्दे को खोलने के लिए धन्यवाद हैडली।

:+1: आज उसी मुद्दे में भाग गया, drop = FALSE मेरे लिए एक बड़ी मदद होगी!

dplyr में .drop = FALSE समतुल्य डालने की समय सीमा पर कोई विचार? कुछ rCharts को सही ढंग से प्रस्तुत करने के लिए मुझे इसकी आवश्यकता है।

इस बीच मुझे आपके काम के लिंक में जवाब मिल गया।
http://stackoverflow.com/questions/22523131

मैंने दो चर द्वारा समूहीकृत किया।

+1 खाली समूहों को न छोड़ने के विकल्प के लिए

#486 और #413 के साथ कुछ ओवरलैप हो सकता है।

खाली समूहों को न छोड़ना बहुत उपयोगी होगा। सारांश तालिकाएँ बनाते समय अक्सर इसकी आवश्यकता होती है।

+1 - यह कई विश्लेषणों के लिए एक डील-ब्रेकर है

मैं उपरोक्त सभी से सहमत हूं - बहुत उपयोगी होगा।

@romainfrancois वर्तमान में build_index_cpp() ड्रॉप विशेषता का सम्मान नहीं करता है:

t1 <- data_frame(
  x = runif(10),
  g1 = rep(1:2, each = 5),
  g2 = factor(g1, 1:3)
)
g1 <- grouped_df(t1, list(quote(g2)), drop = FALSE)
attr(g1, "group_size")
# should be c(5L, 5L, 0L)
attr(g1, "indices")
# shoud be list(0:4, 5:9, integer(0))

ड्रॉप एट्रिब्यूट केवल तभी लागू होता है जब किसी कारक द्वारा समूहीकृत किया जाता है, इस मामले में हमें प्रति कारक स्तर पर एक समूह की आवश्यकता होती है, भले ही वह स्तर वास्तव में डेटा पर लागू हो या नहीं।

यह निम्नलिखित तरीकों से एकल तालिका क्रियाओं को भी प्रभावित करेगा:

• select() : कोई प्रभाव नहीं
• arrange() : कोई प्रभाव नहीं
• summarise() : शून्य पंक्ति समूहों पर लागू कार्यों को 0-स्तरीय पूर्णांक दिए जाने चाहिए। n() 0 लौटना चाहिए, mean(x) वापस आना चाहिए NaN
• filter() : समूहों का समूह स्थिर रहना चाहिए, भले ही कुछ समूहों में अब कोई पंक्तियाँ न हों
• mutate() : खाली समूहों के लिए भावों का मूल्यांकन करने की आवश्यकता नहीं है

आखिरकार, drop = FALSE डिफ़ॉल्ट होगा, और यदि drop = FALSE और drop = TRUE शाखाओं को लिखने में परेशानी होती है, तो मैं खुशी से drop = FALSE लिए समर्थन छोड़ दूंगा ( चूंकि आप हमेशा कारक को फिर से स्तरित कर सकते हैं, या इसके बजाय एक चरित्र वेक्टर का उपयोग कर सकते हैं)।

क्या इसका कोई मतलब है? यदि यह बहुत अधिक काम है, तो हम 0.4 . तक आगे बढ़ सकते हैं

@statwonk , @wsurles , @jennybc , @slackline , @mcfrank , @eipi10 यदि आप मदद करना चाहते हैं, तो सबसे अच्छी बात यह होगी कि परीक्षण मामलों के एक सेट पर काम किया जाए जो विभिन्न क्रियाओं के परस्पर क्रिया करने के सभी तरीकों का अभ्यास करता हो। शून्य-लंबाई समूहों के साथ।

आह। मुझे लगता है कि मुझे नहीं पता था कि drop क्या करना चाहिए था। इससे यह स्पष्ट होता है। मुझे नहीं लगता कि यह बहुत काम है।

मैंने पुल अनुरोध # 833 खोला है जो परीक्षण करता है कि उपरोक्त एकल तालिका क्रियाएं शून्य-लंबाई वाले समूहों को सही ढंग से संभालती हैं या नहीं। अधिकांश परीक्षणों पर टिप्पणी की जाती है, क्योंकि dplyr वर्तमान में उन्हें विफल कर देता है, निश्चित रूप से।

+1, यहां कोई स्थिति अपडेट है? प्यार का सारांश, खाली स्तर रखने की जरूरत है!

@ebergelson , शून्य-लंबाई वाले समूह प्राप्त करने के लिए मेरा वर्तमान हैक यहां है। मुझे अक्सर इसकी आवश्यकता होती है इसलिए मेरे बार चार्ट ढेर हो जाएंगे।

यहां df में 3 कॉलम हैं: नाम, समूह और मीट्रिक

df2 <- expand.grid(name = unique(df$name), group = unique(df$group)) %>%
    left_join(df, by=c("name","group")) %>%
    mutate(metric = ifelse(is.na(metric),0,metric))

मैं कुछ ऐसा ही करता हूं - लापता समूहों की जांच करें, फिर यदि कोई सभी संयोजन उत्पन्न करता है और left_join ।

दुर्भाग्य से, ऐसा नहीं लगता कि इस मुद्दे को बहुत अधिक प्यार मिल रहा है... शायद इसलिए कि इसका सीधा-सीधा समाधान है।

@wsurles , @bpbond धन्यवाद, हाँ मैंने आपके सुझाव के समान ही वर्कअराउंड का उपयोग किया है! .ड्रॉप जैसे बिल्ट-इन फिक्स देखना पसंद करेंगे।

बस उपरोक्त सभी को जोड़ने और सहमत होने के लिए - यह कई विश्लेषणों का एक अति महत्वपूर्ण पहलू है। एक कार्यान्वयन देखना पसंद करेंगे।

यहां कुछ और विवरणों की आवश्यकता है:

अगर मेरे पास यह है:

> df <- data_frame( x = c(1,1,1,2,2), f = factor( c(1,2,3,1,1) ) )
> df
Source: local data frame [5 x 2]

  x f
1 1 1
2 1 2
3 1 3
4 2 1
5 2 1

और मैं x फिर f द्वारा समूहित करता हूं, मैं 6 (2x3) समूहों के साथ समाप्त होता हूं जहां समूह (2, 2) और (2,3) खाली हैं। ठीक है। मुझे लगता है कि मैं इसे लागू करने का प्रबंधन कर सकता हूं।

अब, अगर मेरे पास यह है तो क्या होगा:

> df <- data_frame( f = factor( c(1,1,2,2), levels = 1:3), x = c(1,2,1,4) )
> df
Source: local data frame [4 x 2]

  f x
1 1 1
2 1 2
3 2 1
4 2 4

और मैं f फिर x आधार पर समूह बनाना चाहता हूं। समूह क्या होंगे? @ हैडली

दोनों stats::aggregate और plyr::ddply इस मामले में 4 समूहों को लौटाते हैं (1,1; 1,2; 2,1; और 2,4), इसलिए मैं सुझाव दूंगा कि यह व्यवहार के अनुरूप है .

क्या यह इसके बजाय table() सहमत नहीं होना चाहिए, यानी, 9 समूह लौटाएं?

> table(df$f, df$x)
  1 2 4
1 1 1 0
2 1 0 1
3 0 0 0

मुझे उम्मीद है कि df %>% group_by(f, x) %>% tally मूल रूप से with(df, as.data.frame(table(f, x))) और ddply(df, .(f, x), nrow, .drop=FALSE) जैसा ही परिणाम देगा।

मैंने सोचा था कि हमारा वांछित व्यवहार शून्य-लंबाई वाले समूहों को संरक्षित करना था यदि वे कारक हैं (जैसे .drop में plyr), तो मुझे लगता है कि हम @huftis का सुझाव चाहते हैं। मैं सुझाव दूंगा कि डिफ़ॉल्ट होना ड्रॉप = सच है, ताकि डिफ़ॉल्ट व्यवहार में बदलाव न हो, फिर से

हम्म, मेरे सिर को ठीक उसी तरह लपेटना मुश्किल है जैसा व्यवहार होना चाहिए। क्या ये बहुत ही सरल विचार प्रयोग सही लगते हैं?

df <- data_frame(x = 1, y = factor(1, levels = 2))
df %>% group_by(x) %>% summarise(n())
#> x n
#> 1 1  

df %>% group_by(y) %>% summarise(n())
#> y n
#> 1 1
#> 2 0

df %>% group_by(x, y) %>% summarise(n()
#> x y n
#> 1 1 1
#> 1 2 0

लेकिन क्या होगा यदि x में एकाधिक मान हों? क्या इसे इस तरह काम करना चाहिए?

df <- data_frame(x = 1:2, y = factor(1, levels = 2))
df %>% group_by(x, y) %>% summarise(n()
#> x y n
#> 1 1 1
#> 2 1 1
#> 1 1 0
#> 2 2 0

हो सकता है कि खाली समूहों को संरक्षित करना केवल एक चर द्वारा समूहित करते समय ही समझ में आता है? यदि हम इसे अधिक वास्तविक रूप से फ्रेम करते हैं, उदाहरण के लिए data_frame(age_group = c(40, 60), sex = factor(M, levels = c("F", "M")) क्या आप वास्तव में महिलाओं के लिए गिनती चाहते हैं? मुझे लगता है कि कभी-कभी आप करेंगे और कभी-कभी आप नहीं करेंगे। सभी संयोजनों का विस्तार करना मेरे लिए कुछ अलग ऑपरेशन जैसा लगता है (और कारकों के उपयोग से स्वतंत्र)।

शायद group_by को drop और expand तर्कों की आवश्यकता है? drop = FALSE डेटा में प्रकट नहीं होने वाले कारक स्तरों द्वारा उत्पन्न सभी आकार शून्य समूहों को रखेगा। expand = TRUE डेटा में दिखाई नहीं देने वाले मानों के संयोजन से उत्पन्न सभी आकार के शून्य समूहों को रखेगा।

@ हैडली आपके उदाहरण मुझे सही लगते हैं (मान levels = 1:2 , न कि levels = 2 )। और मुझे लगता है कि कई चर द्वारा समूहबद्ध करते समय भी खाली समूहों को संरक्षित करना समझ में आता है। उदाहरण के लिए, यदि चर sex ( male और female ) और answer (प्रश्नावली पर, स्तरों के साथ disagree , neutral , agree ), और आप प्रत्येक लिंग के लिए प्रत्येक उत्तर की आवृत्ति की गणना करना चाहते हैं (उदाहरण के लिए एक तालिका के लिए, या बाद में प्लॉटिंग के लिए), आप केवल एक उत्तर श्रेणी को छोड़ना नहीं चाहेंगे क्योंकि किसी महिला ने इसका उत्तर नहीं दिया।

मैं परिणामी data_frame (स्ट्रिंग्स में परिवर्तित नहीं) और _मूल स्तरों_ के साथ कारक चर के कारक चर बने रहने की भी अपेक्षा करता हूं। (इसलिए डेटा प्लॉट करते समय, उत्तर श्रेणियां सही क्रम में होंगी, न कि वर्णमाला agree , disagree , neutral )।

आपके अंतिम उदाहरण के लिए, _कुछ मामलों में_ sex चर को गिराना स्वाभाविक होगा (उदाहरण के लिए, यदि _जानबूझकर_ किसी महिला का सर्वेक्षण नहीं किया गया था), और _अन्य मामलों में_ नहीं (उदाहरण के लिए, स्तरीकृत जन्म दोषों की संख्या की गणना करते समय) लिंग (और शायद वर्ष))। लेकिन यह (और चाहिए) आसानी से _after_ डेटा एकत्र करने के साथ निपटाया जा सकता है। (एक अलग समाधान _vector-valued_ .drop तर्क को स्वीकार करना होगा। यह अच्छा होगा, लेकिन मुझे लगता है कि यह चीजों को जटिल कर सकता है?)

(एक अलग समाधान वेक्टर-मूल्यवान .drop तर्क को स्वीकार करना होगा। यह अच्छा होगा, लेकिन मुझे लगता है कि यह चीजों को जटिल कर सकता है?)

हाँ, शायद बहुत जटिल। अन्यथा मैं @huftis की टिप्पणियों से सहमत हूं।

@ हैडली
मुझे लगता है
हाँ मानों के सभी संयोजनों पर समूह_बी में विस्तार करें यदि वे डेटा में मौजूद हैं।
NO उन कारक स्तरों पर विस्तार न करें जो मौजूद नहीं हैं।

मेरा अक्सर उपयोग किया जाने वाला मामला चार्ट के लिए सारांशित डेटा का एक सेट तैयार कर रहा है (अन्वेषण के दौरान)। और चार्ट में मानों के सभी संयोजन होने चाहिए। लेकिन उन्हें सभी समूहों के लिए 0 वाले कारक स्तर की आवश्यकता नहीं है .. उदाहरण के लिए आप सभी संयोजनों के बिना बार चार्ट को स्टैक नहीं कर सकते। लेकिन आपको ऐसे कारक मानों की आवश्यकता नहीं है जो डेटा में मौजूद नहीं हैं, ये केवल 0 होंगे जब स्टैक किया जाएगा और किंवदंती में एक खाली मान होगा।

मेरा मानना ​​​​है कि समूह_बी में सभी मानों पर विस्तार करना डिफ़ॉल्ट होना चाहिए क्योंकि यदि आवश्यक हो तो समूह के बाद 0 मामलों को फ़िल्टर करना बहुत आसान (और अधिक सहज) होना चाहिए। मुझे नहीं लगता कि .ड्रॉप तर्क आवश्यक है, क्योंकि 0 मामलों को फ़िल्टर करना काफी आसान है। हम किसी भी अन्य फ़ंक्शन के लिए अतिरिक्त तर्कों का उपयोग नहीं करते हैं, इसलिए यह मोल्ड को तोड़ देगा। डिफ़ॉल्ट केवल group_by के आधार पर मौजूदा मानों के सभी संयोजनों के लिए परिणाम दिखाने के लिए होना चाहिए।

मुझे लगता है कि यह सही डिफ़ॉल्ट व्यवहार होगा। यहां अद्वितीय केवल कारक में मौजूदा मूल्यों पर विस्तार करेगा, सभी कारक स्तरों पर नहीं। (यह वही है जो मैं समूह_बी चलाने के बाद चलाता हूं जो 0 मान छोड़ देता है)

## Expand data so plot groups works correctly
  df2 <- expand.grid(name = unique(df$name), group = unique(df$group)) %>%
    left_join(df, by=c("name","group")) %>%
    mutate(
      measure = ifelse(is.na(measure),0,measure)
    )

एकमात्र मामला मैं देख सकता हूं कि आप एक मूल्य कहां चाहते हैं, भले ही सभी समूहों में शून्य समय डेटा के साथ हो। हो सकता है कि बीच में कहीं डेटा का एक दिन गायब हो। यहां एक तिथि सीमा पर विस्तार और शामिल होना अभी भी आवश्यक होगा। कारक स्तर का मामला लागू नहीं होगा। मुझे लगता है कि डेटा क्रंचर के लिए लापता तिथियों को स्वयं ही संभालना उचित है।

इस पुस्तकालय पर आपके सभी महान कार्यों के लिए धन्यवाद। मेरी नौकरी का 90% dplyr का उपयोग कर रहा है। : )

मैं @huftis से पूरी तरह सहमत हूं।

मुझे नहीं लगता कि स्तरों के गिरने या स्तरों के संयोजन का डेटा से कोई लेना-देना होना चाहिए। हो सकता है कि आप एक छोटे से नमूने का उपयोग करके किसी फ़ंक्शन या आकृति का प्रोटोटाइप बना रहे हों। या स्प्लिट-अप्लाई-कम्बाइन ऑपरेशन करते हुए, जिस स्थिति में आप एक गारंटी चाहते हैं कि प्रत्येक समूह का आउटपुट बाकी सभी के अनुरूप होगा।

मेरी स्थिति को नरम करना: मुझे लगता है कि यह विचार करने योग्य है कि क्या डिफ़ॉल्ट व्यवहार भिन्न होना चाहिए जब समूह चर पहले से ही एक उचित कारक है बनाम जब इसे कारक के लिए मजबूर किया जा रहा हो। मैं देख सकता हूं कि जबरदस्ती के मामले में अप्रयुक्त स्तरों को रखने की बाध्यता कम हो सकती है। लेकिन अगर मैं किसी चीज़ को एक कारक के रूप में स्थापित करने और स्तरों को नियंत्रित करने के लिए मुसीबत में पड़ गया हूँ ... तो आमतौर पर एक अच्छा कारण होता है और मैं इसे बनाए रखने के लिए लगातार संघर्ष नहीं करना चाहता।

FYIW, मैं इस सुविधा को भी देखना चाहूंगा। मेरे पास एक समान परिदृश्य है जैसा कि @huftis द्वारा वर्णित है और मुझे आवश्यक परिणाम प्राप्त करने के लिए हुप्स के माध्यम से कूदना है।

एसओ से यहां आया था। क्या यह "tidyr" से complete मदद करने वाला नहीं है?

हाँ ऐसा होता है। मैंने वास्तव में हाल ही में 'पूर्ण' के बारे में सीखा है और ऐसा लगता है कि इसे एक विचारशील तरीके से पूरा किया गया है।

SQL बैकएंड के लिए इसे लागू करना मुश्किल लगता है, क्योंकि वे डिफ़ॉल्ट रूप से सभी समूहों को छोड़ देंगे। क्या हम इसे उस पर छोड़ दें और शायद SQL के लिए tidyr::complete() लागू करें?

मैंने मुद्दा # 3033 बनाया है, यह महसूस नहीं कर रहा है कि यह समस्या पहले से मौजूद है - डुप्लिकेट के लिए खेद है। अपना विनम्र सुझाव जोड़ने के लिए, मैं वर्तमान में pull() और forcats::fct_count() का उपयोग इस मुद्दे के

मैं इस पद्धति का प्रशंसक नहीं हूं, हालांकि fct_count() एक आउटपुट बनाने के tidyverse सिद्धांत को धोखा देता है जो हमेशा इनपुट के समान प्रकार होता है (यानी यह फ़ंक्शन वेक्टर से एक टिबल बनाता है), और मेरे पास है आउटपुट में कॉलम का नाम बदलने के लिए। यह 3 चरण बनाता है ( pull() %>% fct_count() %>% rename() ) जब dplyr::count() एक को कवर करने के लिए था। यह शानदार होगा यदि forcats::fct_count() और dplyr::count() को किसी भी तरह से समामेलित किया जा सकता है, और forcats::fct_count() हटा दिया जा सकता है।

क्या tidyr::complete() कारकों के लिए काम करता है?

कारक स्तरों के सभी कारक स्तरों और संयोजनों को डिफ़ॉल्ट रूप से संरक्षित किया जाना चाहिए। इस व्यवहार को drop , expand , आदि जैसे मापदंडों द्वारा नियंत्रित किया जा सकता है। इस प्रकार dplyr::count() का डिफ़ॉल्ट व्यवहार इस तरह होना चाहिए:

df <- data.frame(x = 1:2, y = factor(c(1, 1), levels = 1:2))
df %>% dplyr::count(x, y)
#>  # A tibble: 4 x 3
#>       x        y       n
#>     <int>   <fct>    <int>
#> 1     1        1       1
#> 2     2        1       1
#> 3     1        2       0
#> 4     2        2       0

शून्य लंबाई समूह (समूहों के संयोजन) को बाद में फ़िल्टर किया जा सकता है। लेकिन खोजपूर्ण विश्लेषण के लिए हमें पूरी तस्वीर देखनी होगी।

1. क्या इस मुद्दे के समाधान पर कोई स्थिति अद्यतन है?
2. क्या इस मुद्दे को पूरी तरह से हल करने की कोई योजना है?

2: हाँ निश्चित रूप से
1: इस मुद्दे के बारे में कुछ तकनीकी कार्यान्वयन कठिनाइयां हैं, लेकिन मैं इसे अगले कुछ हफ्तों में देखूंगा।

तथ्य के बाद डेटा का विस्तार करके हम इससे दूर हो सकते हैं, ऐसा कुछ:

library(tidyverse)

truly_group_by <- function(data, ...){
  dots <- quos(...)
  data <- group_by( data, !!!dots )

  labels <- attr( data, "labels" )
  labnames <- names(labels)
  labels <- mutate( labels, ..index.. =  attr(data, "indices") )

  expanded <- labels %>%
    tidyr::expand( !!!dots ) %>%
    left_join( labels, by = labnames ) %>%
    mutate( ..index.. = map(..index.., ~if(is.null(.x)) integer() else .x ) )

  indices <- pull( expanded, ..index..)
  group_sizes <- map_int( indices, length)
  labels <- select( expanded, -..index..)

  attr(data, "labels")  <- labels
  attr(data, "indices") <- indices
  attr(data, "group_sizes") <- group_sizes

  data
}

df  <- data_frame(
  x = 1:2,
  y = factor(c(1, 1), levels = 1:2)
)
tally( truly_group_by(df, x, y) )
#> # A tibble: 4 x 3
#> # Groups:   x [?]
#>       x y         n
#>   <int> <fct> <int>
#> 1     1 1         1
#> 2     1 2         0
#> 3     2 1         1
#> 4     2 2         0
tally( truly_group_by(df, y, x) )
#> # A tibble: 4 x 3
#> # Groups:   y [?]
#>   y         x     n
#>   <fct> <int> <int>
#> 1 1         1     1
#> 2 1         2     1
#> 3 2         1     0
#> 4 2         2     0

स्पष्ट रूप से लाइन के नीचे, इसे आंतरिक रूप से संभाला जाएगा, बिना tidyr या purrr का उपयोग करके।

ऐसा लगता है कि मूल प्रश्न का ख्याल रखना है:

> df = data.frame(a=rep(1:3,4), b=rep(1:2,6))
> df$b = factor(df$b, levels=1:3)
> df %>%
+   group_by(b) %>%
+   summarise(count_a=length(a), .drop=FALSE)
# A tibble: 2 x 3
  b     count_a .drop
  <fct>   <int> <lgl>
1 1           6 FALSE
2 2           6 FALSE
> df %>%
+   truly_group_by(b) %>%
+   summarise(count_a=length(a), .drop=FALSE)
# A tibble: 3 x 3
  b     count_a .drop
  <fct>   <int> <lgl>
1 1           6 FALSE
2 2           6 FALSE
3 3           0 FALSE

यहाँ कुंजी यह है

 tidyr::expand( !!!dots ) %>%

जिसका अर्थ है सभी संभावनाओं का विस्तार करना, भले ही चर कारक हों या न हों।

मैं कहूंगा कि हम या तो:

• सभी का विस्तार करें जब drop=FALSE , संभावित रूप से बहुत सारे 0 लंबाई समूह हों
• अगर हम drop=TRUE

शायद ड्रॉपनेस को टॉगल करने के लिए एक फ़ंक्शन है।

यह एक अपेक्षाकृत सस्ता ऑपरेशन है जो मैं कहूंगा क्योंकि इसमें केवल मेटाडेटा में हेरफेर करना शामिल है, इसलिए शायद पहले आर में ऐसा करना कम जोखिम भरा है?

क्या आपका मतलब crossing() बजाय expand() ?

इंटर्नल को देखते हुए, क्या आप सहमत हैं कि ऐसा करने के लिए हमें "केवल" build_index_cpp() , विशेष रूप से labels डेटा फ्रेम की पीढ़ी को बदलने की आवश्यकता है?

क्या हम शायद drop = FALSE साथ केवल कारकों के विस्तार के साथ शुरुआत कर सकते हैं? मैंने एक "प्राकृतिक" वाक्यविन्यास माना, लेकिन यह अंत में बहुत भ्रमित हो सकता है (और शायद पर्याप्त शक्तिशाली भी नहीं):

group_by(data, crossing(col1, col2), col3)

सिमेंटिक्स: col1 और col2 सभी संयोजनों का उपयोग करना, और col3 साथ मौजूदा संयोजन हैं।

हां, मैं कहूंगा कि यह केवल build_index_cpp और विशेषताओं की पीढ़ी को प्रभावित करता है labels , indices और group_sizes जिसे मैं एक में स्क्वैश करना चाहता हूं #3489 . के हिस्से के रूप में सुव्यवस्थित संरचना

इस चर्चा का "केवल विस्तार करने वाले कारक" हिस्से में इतना समय लगा।

इनके परिणाम क्या होंगे:

library(dplyr)

d <- data_frame(
  f1 = factor( rep( c("a", "b"), each = 4 ), levels = c("a", "b", "c") ),
  f2 = factor( rep( c("d", "e", "f", "g"), each = 2 ), levels = c("d", "e", "f", "g", "h") ),
  x  = 1:8,
  y  = rep( 1:4, each = 2)
)

f <- function(data, ...){
  group_by(data, !!!quos(...))  %>%
    tally()
}
f(d, f1, f2, x)
f(d, x, f1, f2)

f(d, f1, f2, x, y)
f(d, x, f1, f2, y)

मुझे लगता है कि f(d, f1, f2, x) को f(d, x, f1, f2) के समान परिणाम देना चाहिए, यदि पंक्ति क्रम को अनदेखा किया जाता है। बाकी दो के लिए भी समान।

यह भी दिलचस्प:

f(d, f2, x, f1, y)
d %>% sample_frac(0.3) %>% f(...)

मुझे केवल कारकों के लिए पूर्ण विस्तार लागू करने का विचार पसंद है। गैर-चरित्र डेटा (तार्किक सहित) के लिए, हम एक कारक-समान वर्ग को परिभाषित/उपयोग कर सकते हैं जो संबंधित डेटा प्रकार को प्राप्त करता है। शायद forcats द्वारा प्रदान किया

#3492 . में कार्यान्वयन प्रगति पर है

library(dplyr)
#> 
#> Attaching package: 'dplyr'
#> The following objects are masked from 'package:stats':
#> 
#>     filter, lag
#> The following objects are masked from 'package:base':
#> 
#>     intersect, setdiff, setequal, union
df <- data_frame( f = factor( c(1,1,2,2), levels = 1:3), x = c(1,2,1,4) )

( res1 <- tally(group_by(df,f,x, drop = FALSE)) )
#> # A tibble: 9 x 3
#> # Groups:   f [?]
#>   f         x     n
#>   <fct> <dbl> <int>
#> 1 1        1.     1
#> 2 1        2.     1
#> 3 1        4.     0
#> 4 2        1.     1
#> 5 2        2.     0
#> 6 2        4.     1
#> 7 3        1.     0
#> 8 3        2.     0
#> 9 3        4.     0
( res2 <- tally(group_by(df,x,f, drop = FALSE)) )
#> # A tibble: 9 x 3
#> # Groups:   x [?]
#>       x f         n
#>   <dbl> <fct> <int>
#> 1    1. 1         1
#> 2    1. 2         1
#> 3    1. 3         0
#> 4    2. 1         1
#> 5    2. 2         0
#> 6    2. 3         0
#> 7    4. 1         0
#> 8    4. 2         1
#> 9    4. 3         0

all.equal( res1, arrange(res2, f, x) )
#> [1] TRUE

all.equal( filter(res1, n>0), tally(group_by(df, f, x)) )
#> [1] TRUE
all.equal( filter(res2, n>0), tally(group_by(df, x, f)) )
#> [1] TRUE

रेप्रेक्स पैकेज (

जैसे कि complete() इस मुद्दे को हल करता है - नहीं, वास्तव में नहीं। जो भी सारांश की गणना की जा रही है, खाली वैक्टर पर उनके व्यवहार को संरक्षित करने की आवश्यकता है, न कि तथ्य के बाद पैच अप करने की। उदाहरण के लिए:

data.frame(x=factor(1, levels=1:2), y=4:5) %>%
     group_by(x) %>%
     summarize(min=min(y), sum=sum(y), prod=prod(y))
# Should be:
#> x       min   sum  prod
#> 1         4     9    20
#> 2       Inf     0     1

sum और prod (और कुछ हद तक, min ) (और कई अन्य कार्यों) में खाली वैक्टर पर बहुत अच्छी तरह से परिभाषित शब्दार्थ हैं, और यह बहुत अच्छा नहीं है बाद में complete() साथ आएं और उन व्यवहारों को फिर से परिभाषित करें।

@kenahoo मुझे यकीन नहीं है कि मैं समझता हूं। यह वही है जो आपको वर्तमान देव संस्करण के साथ मिलता है। तो केवल एक चीज जो आपको नहीं मिलती वह है min() से चेतावनी

library(dplyr)

data.frame(x=factor(1, levels=1:2), y=4:5) %>%
  group_by(x) %>%
  summarize(min=min(y), sum=sum(y), prod=prod(y))
#> # A tibble: 2 x 4
#>   x       min   sum  prod
#>   <fct> <dbl> <int> <dbl>
#> 1 1         4     9    20
#> 2 2       Inf     0     1

min(integer())
#> Warning in min(integer()): no non-missing arguments to min; returning Inf
#> [1] Inf
sum(integer())
#> [1] 0
prod(integer())
#> [1] 1

रेप्रेक्स पैकेज (

@romainfrancois ओह कूल, मुझे नहीं पता था कि आप इस कार्यान्वयन पर पहले से ही बहुत दूर थे। अच्छा लग रहा है!

यह पुराना इश्यू अपने आप लॉक हो गया है। यदि आपको लगता है कि आपको कोई संबंधित समस्या मिली है, तो कृपया एक नया मुद्दा (रेप्रेक्स के साथ) दर्ज करें और इस मुद्दे से लिंक करें। https://reprex.tidyverse.org/