dplyr में .dots = setNames() के लिए महत्वपूर्ण सूची() का उपयोग क्यों कर रहा है?

Question

मैं गतिशील परिवर्तनीय नामों का उपयोग करके उत्परिवर्ती कॉल कर रहा हूं। एक उदाहरण है कि ज्यादातर काम करता है:

df <- data.frame(a = 1:5, b = 1:5) 
func <- function(a,b){ 
    return(a+b) 
} 
var1 = 'a' 
var2 = 'b' 
expr <- interp(~func(x, y), x = as.name(var1), y = as.name(var2)) 
new_name <- "dynamically_created_name" 
temp <- df %>% mutate_(.dots = setNames(expr, nm = new_name)) 

कौन सा

temp 
    a b func(a, b) 
1 1 1   2 
2 2 2   4 
3 3 3   6 
4 4 4   8 
5 5 5   10 

पैदा करता है यह ज्यादातर ठीक सिवाय इसके कि सेट नाम पर ध्यान नहीं दिया एनएम की कुंजी है। इस सूची() में अपने समारोह लपेटकर द्वारा हल किया जाता है:

temp <- df %>% mutate_(.dots = setNames(list(expr), nm = new_name)) 
temp 
    a b dynamically_created_name 
1 1 1      2 
2 2 2      4 
3 3 3      6 
4 4 4      8 
5 5 5      10 

मेरा प्रश्न क्यों setNames अनदेखी कर रहा है यह पहली जगह में कुंजी है, और कैसे सूची() इस समस्या को हल करता है?

Answer 1

vignettes("nse") से:

आप भी भिन्न करने आउटपुट चर करना चाहते हैं, तो आप .dots तर्क को उद्धृत वस्तुओं की एक सूची में उत्तीर्ण होना

तो शायद कारण है कि

temp <- df %>% mutate_(.dots = setNames(expr, nm = new_name)) 

जो भी आप चाहते हैं वह नहीं करता है, जबकि आपने सफलतापूर्वक यहां नाम विशेषता सेट की है, expr sti है एक सूत्र करेंगे, नहीं एक सूची:

foo <- setNames(expr, nm = new_name) 
names(foo) #"dynamically_created_name" "" 
class(foo) #"formula" 

तो अगर आप इसे एक सूची बनाना, यह उम्मीद के रूप में काम करता है:

expr <- interp(~func(x, y), x = as.name(var1), 
       y = as.name(var2)) 
df %>% mutate_(.dots = list(new_name = expr)) 
    a b new_name 
1 1 1  2 
2 2 2  4 
3 3 3  6 
4 4 4  8 
5 5 5  10 

Answer 2

रूप other answer में बताया गया है, .dots तर्क एक माना जाता है सूची, और सेटनाम एक सूची में तत्वों का नाम बदलने का एक सुविधाजनक तरीका है।

। डॉट्स तर्क क्या कर रहा है? आइए सबसे पहले वास्तविक बिंदु ... तर्क के बारे में सोचें। यह मूल्यांकन के लिए अभिव्यक्तियों की एक श्रृंखला है। बिंदुओं के नीचे ... दो नामित अभिव्यक्ति c = ~ a * scale1 और d = ~ a * scale2 हैं।

scale1 <- -1 
scale2 <- -2 

df %>% 
    mutate_(c = ~ a * scale1, d = ~ a * scale2) 
#> a b c d 
#> 1 1 1 -1 -2 
#> 2 2 2 -2 -4 
#> 3 3 3 -3 -6 
#> 4 4 4 -4 -8 
#> 5 5 5 -5 -10 

हम सूची में पहले से ही उन अभिव्यक्तियों को एक साथ जोड़ सकते हैं। यही वह जगह है जहां डॉट्स आते हैं। वह पैरामीटर हमें सूची में अभिव्यक्तियों का मूल्यांकन करने के लिए mutate_ बताता है।

bundled <- list(
    c2 = ~ a * scale1, 
    d2 = ~ a * scale2 
) 

df %>% 
    mutate_(.dots = bundled) 
#> a b c2 d2 
#> 1 1 1 -1 -2 
#> 2 2 2 -2 -4 
#> 3 3 3 -3 -6 
#> 4 4 4 -4 -8 
#> 5 5 5 -5 -10 

हम प्रोग्राम के रूप में सूची में भाव के नाम को अपडेट करना चाहते हैं, तो setNames कि करने के लिए एक सुविधाजनक तरीका है। यदि हम अभिव्यक्ति करते समय प्रोग्रामेटिक रूप से स्थिरांक और परिवर्तनीय नामों को मिलान करना चाहते हैं, तो lazyeval पैकेज ऐसा करने के सुविधाजनक तरीके प्रदान करता है। नीचे मैं दोनों भाव की एक सूची बनाने के लिए, उन्हें नाम, और उनके साथ mutate_

# Imagine some dropdown boxes in a Shiny app, and this is what user requested 
selected_func1 <- "min" 
selected_func2 <- "max" 
selected_var1 <- "a" 
selected_var2 <- "b" 

# Assemble expressions from those choices 
bundled2 <- list(
    interp(~fun(x), fun = as.name(selected_func1), x = as.name(selected_var1)), 
    interp(~fun(x), fun = as.name(selected_func2), x = as.name(selected_var2)) 
) 
bundled2 
#> [[1]] 
#> ~min(a) 
#> 
#> [[2]] 
#> ~max(b) 

# Create variable names 
exp_name1 <- paste0(selected_func1, "_", selected_var1) 
exp_name2 <- paste0(selected_func2, "_", selected_var2) 

bundled2 <- setNames(bundled2, c(exp_name1, exp_name2)) 
bundled2 
#> $min_a 
#> ~min(a) 
#> 
#> $max_b 
#> ~max(b) 

# Evaluate the expressions 
df %>% 
    mutate_(.dots = bundled2) 
#> a b min_a max_b 
#> 1 1 1  1  5 
#> 2 2 2  1  5 
#> 3 3 3  1  5 
#> 4 4 4  1  5 
#> 5 5 5  1  5