R Language
पाइप ऑपरेटर (%>% और अन्य)

परिचय

वाक्य - विन्यास

• lhs%>% rhs # rhs(lhs) लिए पाइप सिंटैक्स

• lhs%>% rhs (a = 1) # पाइप वाक्यविन्यास rhs(lhs, a = 1)

• lhs%>% rhs (a = 1, b =।) # पाइप सिंटैक्स rhs(a = 1, b = lhs)

• lhs% <>% rhs # lhs <- rhs(lhs) लिए पाइप सिंटैक्स lhs <- rhs(lhs)

• lhs% $% rhs (a) # पाइप सिंटैक्स के with(lhs, rhs(lhs$a))

• lhs% T>% rhs # पाइप वाक्यविन्यास { rhs(lhs); lhs }

पैरामीटर

टिप्पणियों

मूल उपयोग और जंजीर

पाइप ऑपरेटर, %>% , एक फ़ंक्शन में एक तर्क सम्मिलित करने के लिए उपयोग किया जाता है। यह भाषा की आधार विशेषता नहीं है और इसका उपयोग केवल पैकेज प्रदान करने के बाद किया जा सकता है, जो इसे प्रदान करता है, जैसे कि magrittr । पाइप ऑपरेटर पाइप के बाएं-हाथ की ओर (LHS) लेता है और इसे पाइप के दाहिने-हाथ (RHS) पर फ़ंक्शन के पहले तर्क के रूप में उपयोग करता है। उदाहरण के लिए:

library(magrittr)

1:10 %>% mean
# [1] 5.5

# is equivalent to
mean(1:10)
# [1] 5.5

फ़ंक्शन कॉल के अनुक्रम को बदलने के लिए पाइप का उपयोग किया जा सकता है। कई पाइप हमें अंदर से बाहर की बजाय बाएं से दाएं अनुक्रम को पढ़ने और लिखने की अनुमति देते हैं। उदाहरण के लिए, मान लें कि हमारे पास एक कारक के रूप में परिभाषित years , लेकिन इसे एक संख्यात्मक में बदलना चाहते हैं। संभावित जानकारी हानि को रोकने के लिए, हम पहले वर्ण में और फिर संख्यात्मक में परिवर्तित होते हैं:

years <- factor(2008:2012)

# nesting
as.numeric(as.character(years))

# piping
years %>% as.character %>% as.numeric

यदि हम नहीं चाहते कि LHS (लेफ्ट हैंड साइड) RHS (राइट हैंड साइड) पर पहले तर्क के रूप में इस्तेमाल किया जाए, तो वर्कअराउंड होते हैं, जैसे कि तर्कों का नामकरण या उपयोग करना . इंगित करने के लिए कि पाइप इनपुट कहां जाता है।

# example with grepl
# its syntax:
# grepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE)

# note that the `substring` result is the *2nd* argument of grepl
grepl("Wo", substring("Hello World", 7, 11))

# piping while naming other arguments
"Hello World" %>% substring(7, 11) %>% grepl(pattern = "Wo")

# piping with .
"Hello World" %>% substring(7, 11) %>% grepl("Wo", .)

# piping with . and curly braces
"Hello World" %>% substring(7, 11) %>% { c(paste('Hi', .)) }
#[1] "Hi World"

#using LHS multiple times in argument with curly braces and .
"Hello World" %>% substring(7, 11) %>% { c(paste(. ,'Hi', .)) }
#[1] "World Hi World"

क्रियात्मक क्रम

हमारे द्वारा बार-बार उपयोग किए जाने वाले चरणों के अनुक्रम को देखते हुए, इसे अक्सर किसी फ़ंक्शन में संग्रहीत करना आसान होता है। पाइप एक डॉट के साथ एक क्रम शुरू करके पठनीय प्रारूप में ऐसे कार्यों को बचाने की अनुमति देते हैं:

. %>% RHS

एक उदाहरण के रूप में, मान लें कि हमारे पास कारक तिथियां हैं और वर्ष निकालना चाहते हैं:

library(magrittr) # needed to include the pipe operators
library(lubridate)
read_year <- . %>% as.character %>% as.Date %>% year

# Creating a dataset
df <- data.frame(now = "2015-11-11", before = "2012-01-01")
#          now     before
# 1 2015-11-11 2012-01-01

# Example 1: applying `read_year` to a single character-vector
df$now %>% read_year
# [1] 2015

# Example 2: applying `read_year` to all columns of `df`
df %>% lapply(read_year) %>% as.data.frame  # implicit `lapply(df, read_year)
#    now before
# 1 2015   2012

# Example 3: same as above using `mutate_all`
library(dplyr)
df %>% mutate_all(funs(read_year))
# if an older version of dplyr use `mutate_each`
#    now before
# 1 2015   2012

हम फ़ंक्शन की संरचना की समीक्षा उसके नाम या functions का उपयोग करके कर सकते functions :

read_year
# Functional sequence with the following components:
# 
#  1. as.character(.)
#  2. as.Date(.)
#  3. year(.)
# 
# Use 'functions' to extract the individual functions. 

हम प्रत्येक फ़ंक्शन को अनुक्रम में उसकी स्थिति द्वारा भी एक्सेस कर सकते हैं:

read_year[[2]]
# function (.) 
# as.Date(.)

आमतौर पर, यह दृष्टिकोण तब उपयोगी हो सकता है जब स्पष्टता गति से अधिक महत्वपूर्ण हो।

% <>% के साथ असाइनमेंट

magrittr पैकेज में एक कंपाउंड असाइनमेंट magrittr -ऑपरेटर, %<>% , जो पहले एक या एक से अधिक rhs अभिव्यक्तियों में पाइपिंग करके और उसके बाद रिजल्ट असाइन करके एक वैल्यू को अपडेट करता है। यह एक ऑब्जेक्ट नाम को दो बार (असाइनमेंट ऑपरेटर के प्रत्येक पक्ष पर एक बार <- ) टाइप करने की आवश्यकता को समाप्त करता है। %<>% एक श्रृंखला में पहला इन्फिक्स-ऑपरेटर होना चाहिए:

library(magrittr)
library(dplyr)

df <- mtcars

लिखने के बजाय

df <- df %>% select(1:3) %>% filter(mpg > 20, cyl == 6)

या

df %>% select(1:3) %>% filter(mpg > 20, cyl == 6) -> df

यौगिक असाइनमेंट ऑपरेटर दोनों पाइप और पुन: असाइन करेगा df :

df %<>% select(1:3) %>% filter(mpg > 20, cyl == 6)

% $ के साथ एक्सपोजिंग सामग्री

एक्सपोजर पाइप ऑपरेटर, %$% , कॉलम नामों को आर-प्रतीकों के रूप में बाएं हाथ की ओर ऑब्जेक्ट के दाहिने-हाथ की ओर अभिव्यक्ति के रूप में उजागर करता है। यह ऑपरेटर उन कार्यों में पाइपिंग करता है, जिसमें data तर्क नहीं होता है (इसके विपरीत, कहे, lm ) और वह data (फ़िक्स) और स्तंभ नामों को तर्क के रूप में नहीं लेता है (अधिकांश मुख्य dplyr फ़ंक्शन)।

एक्सपोजर पाइप ऑपरेटर %$% एक उपयोगकर्ता को स्तंभ नाम को संदर्भित करने की आवश्यकता होने पर पाइप लाइन को तोड़ने से बचने की अनुमति देता है। उदाहरण के लिए, मान लें कि आप किसी डेटा.फ्रेम को फ़िल्टर करना चाहते हैं और फिर cor.test साथ दो स्तंभों पर सहसंबंध परीक्षण cor.test :

library(magrittr)
library(dplyr)
mtcars %>%
  filter(wt > 2) %$%
  cor.test(hp, mpg)

#> 
#>  Pearson's product-moment correlation
#> 
#> data:  hp and mpg
#> t = -5.9546, df = 26, p-value = 2.768e-06
#> alternative hypothesis: true correlation is not equal to 0
#> 95 percent confidence interval:
#>  -0.8825498 -0.5393217
#> sample estimates:
#>        cor 
#> -0.7595673

यहाँ मानक %>% पाइप filter() माध्यम से data.frame को पार filter() , जबकि %$% पाइप स्तंभ नामों को cor.test() उजागर करता है।

एक्सपोजर पाइप बेस आर with() फ़ंक्शन के with() आधार आर के पाइप-सक्षम संस्करण की तरह काम करता है, और बाएं हाथ की तरफ की वस्तुओं को इनपुट के रूप में स्वीकार किया जाता है।

Dplyr और ggplot2 के साथ पाइप का उपयोग करना

%>% ऑपरेटर का उपयोग dglr आउटपुट को ggplot में पाइप करने के लिए भी किया जा सकता है। यह एक एकीकृत खोज डेटा विश्लेषण (EDA) पाइपलाइन बनाता है जो आसानी से अनुकूलन योग्य है। यह विधि ggplot में आंतरिक रूप से एकत्रीकरण करने की तुलना में तेज़ है और अनावश्यक मध्यवर्ती चर से बचने का अतिरिक्त लाभ है।

library(dplyr)
library(ggplot)


diamonds %>% 
    filter(depth > 60) %>% 
    group_by(cut) %>% 
    summarize(mean_price = mean(price)) %>% 
    ggplot(aes(x = cut, y = mean_price)) + 
        geom_bar(stat = "identity")

% T>% के साथ साइड इफेक्ट बनाना

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

%T>% (टी ऑपरेटर) आपको मूल lhs मान को बरकरार रखते हुए एक साइड-इफ़ेक्ट-प्रोडक्शन फंक्शन में वैल्यू फॉरवर्ड करने की अनुमति देता है। दूसरे शब्दों में: टी ऑपरेटर %>% तरह काम करता है %>% , रिटर्न वैल्यू को छोड़कर, स्वयं ही lhs है, और rhs फ़ंक्शन / एक्सप्रेशन का परिणाम नहीं है।

उदाहरण: एक ऑब्जेक्ट बनाएं, पाइप करें, लिखें और वापस लौटें। यदि इस उदाहरण में %T>% स्थान पर %>% का उपयोग किया गया था, तो चर all_letters में सॉर्ट किए गए ऑब्जेक्ट के मूल्य के बजाय NULL होगा।

all_letters <- c(letters, LETTERS) %>%
    sort %T>% 
    write.csv(file = "all_letters.csv")

read.csv("all_letters.csv") %>% head()
#   x
# 1 a
# 2 A
# 3 b
# 4 B
# 5 c
# 6 C

चेतावनी: save() लिए अनाम ऑब्जेक्ट को पाइप करना save() नाम की ऑब्जेक्ट का उत्पादन करेगा . जब लोड के साथ कार्यक्षेत्र में load() । हालांकि, एक हेल्पर फ़ंक्शन का उपयोग करके एक समाधान संभव है (जिसे एक अनाम फ़ंक्शन के रूप में इनलाइन भी लिखा जा सकता है)।

all_letters <- c(letters, LETTERS) %>%
    sort %T>% 
    save(file = "all_letters.RData")

load("all_letters.RData", e <- new.env())

get("all_letters", envir = e)
# Error in get("all_letters", envir = e) : object 'all_letters' not found

get(".", envir = e)
#  [1] "a" "A" "b" "B" "c" "C" "d" "D" "e" "E" "f" "F" "g" "G" "h" "H" "i" "I" "j" "J" 
# [21] "k" "K" "l" "L" "m" "M" "n" "N" "o" "O" "p" "P" "q" "Q" "r" "R" "s" "S" "t" "T" 
# [41] "u" "U" "v" "V" "w" "W" "x" "X" "y" "Y" "z" "Z"

# Work-around
save2 <- function(. = ., name, file = stop("'file' must be specified")) {
  assign(name, .)
  call_save <- call("save", ... = name, file = file)
  eval(call_save)
}

all_letters <- c(letters, LETTERS) %>%
    sort %T>%
    save2("all_letters", "all_letters.RData")