R में जिप या एनुमुर्ट?

Question 1

इन पायथन सूची समझ के लिए R समतुल्य क्या हैं:

[(i,j) for i,j in zip(index, Values)]
[(i,j) for i,j in enumerate(Values)]
[(i,j) for i,j in enumerate(range(10,20))]   %MWE, indexing or enumerating to 
                                            %keep up with the index, there may 
                                            %be some parameter to look this up

आउटपुट के साथ उदाहरण

>>> [(i,j) for i,j in enumerate(range(10,20))]
[(0, 10), (1, 11), (2, 12), (3, 13), (4, 14), (5, 15), (6, 16), (7, 17), (8, 18), (9, 19)]

मैंने इस समस्या को पहले R में कुछ ट्रिक के साथ हल किया है, लेकिन अब याद नहीं कर सकता, पहला विचार itertools -pkg था, लेकिन मैं चीजों को करने का एक अधिक मुहावरेदार तरीका खोजने की उम्मीद कर रहा हूं।

Question 2

अजगर के लिए जवाब enumerate:

आर में, एक सूची का आदेश दिया गया है ( इस उत्तर को देखें )। इस प्रकार, आपको केवल कुंजी (उपयोग names()[i]) या मान (उपयोग [[i]]) को इंडेक्स करना है ।

का उपयोग कर seq_along(वैकल्पिक रूप से कर सकते हैं for(i in 1:length(mylist)){...}):

> mylist <- list('a'=10,'b'=20,'c'=30)
> for (i in seq_along(mylist)){
+   print(paste(i,names(mylist)[i],mylist[[i]]))
+ }
[1] "1 a 10"
[1] "2 b 20"
[1] "3 c 30"

अजगर के लिए जवाब zip:

ट्यूपल्स की सूची की नकल करने के लिए उपरोक्त उत्तरों में से एक देखें। मेरी प्राथमिकता बॉन्डेडडस्ट के उत्तर में दिखाए गए डेटा फ्रेम की ओर है:

> x <- 1:3
> y <- 4:6
> data.frame(x=x, y=y)
  x y
1 1 4
2 2 5
3 3 6

Question 3

आर के लिए सूची की समझ के आसपास कुछ चर्चाएँ हुई हैं, जैसे यहाँ या वहाँ । हैश पैकेज भी शब्दकोश की तरह संरचना प्रदान करता है। हालांकि, जैसा कि अन्य ने कहा, एक भाषा सुविधाओं को दूसरे पर (भले ही यह प्रोग्रामिंग भाषाओं की तुलना वास्तव में प्रदान करता है) को मैप करने की कोशिश करना मुश्किल है, यह समझने की स्पष्ट समझ के बिना कि इसका उपयोग करने के लिए क्या माना जाता है। उदाहरण के लिए, मैं zip()आर में पायथन की नकल कर सकता हूं :

अजगर

In [1]: x = [1,2,3]
In [2]: y = [4,5,6]
In [3]: zip(x, y)
Out[3]: [(1, 4), (2, 5), (3, 6)]

आर

> x <- 1:3
> y <- 4:6
> list(x, y)                     # gives a simple list
> as.list(paste(x, y))           # three tuples, as a list of characters
> mapply(list, x, y, SIMPLIFY=F) # gives a list of 3 tuples
> rbind(x, y)                    # gives a 2x3 matrix

जैसा कि देखा जा सकता है, यह वास्तव में इस बात पर निर्भर करता है कि आप परिणाम के साथ क्या करना चाहते हैं।

Question 4

एक और विकल्प जो वैक्टर की एक सूची बनाएगा, वह है मानचित्र फ़ंक्शन का उपयोग करने के लिए जैसा कि @peterhurford द्वारा यहां देखा गया है: https://rdrr.io/github/peterhurford/funtools/src/R/zippers.R

> x <- 1:3
> y <- 4:6
> z <- 7:9
> Map(c, x, y, z)

[[1]]
[1] 1 4 7

[[2]]
[1] 2 5 8

[[3]]
[1] 3 6 9

Question 5

यदि वह मैट्रिक्स का पायथन प्रिंट प्रतिनिधित्व है, तो यह कोड:

j <- 10:20
matrix(c(seq_along(j), j), ncol=2)
#------------
      [,1] [,2]
 [1,]    1   10
 [2,]    2   11
 [3,]    3   12
 [4,]    4   13
 [5,]    5   14
 [6,]    6   15
 [7,]    7   16
 [8,]    8   17
 [9,]    9   18
[10,]   10   19
[11,]   11   20

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

@ ची के मार्गदर्शन को देखते हुए हम बहुत ही आर-केंद्रित 'डेटाफ्रेम' संरचना का उपयोग करने का सुझाव दे सकते हैं

x <- 1:3
y <- 4:6
dfrm <- data.frame(x=x, y=y)

... जिसमें स्तंभ प्रकार और पंक्ति और स्तंभ अनुक्रमण के संदर्भ में मैट्रिक्स की पहुंच सुविधाओं के संदर्भ में एक सूची का लचीलापन है। या कोई hhh के अनुरोध का उपयोग कर सकता है और डिफ़ॉल्ट रूप से "1" से शुरू होने 10:20वाले rownamesवेक्टर का उपयोग करके , जे-वेक्टर के निहित अनुक्रमित मूल्यों को बना सकता है, लेकिन जिसे "0" से शुरू होने वाले चरित्र वेक्टर बनने के लिए बदल दिया जा सकता है।

dfrm <- data.frame(j=10:20)
dfrm[3, ]
#[1] 12

 rownames(dfrm) <- 0:10
 dfrm["0",]
# [1] 10

दुर्भाग्य से, यह पता चलेगा कि डरीफाम [0], एक खुश कॉल नहीं है, जिसकी लंबाई 0 की वापसी है।

Question 6

पायनियर शैली की सूची जैसे एन्यूमरेटेड लिस्ट के साथ पायथन शैली का उपयोग करने के लिए, एक तरीका है लिस्ट-कॉम्प्रिहेंशन पैकेज LC(विकसित 2018) और इटर्टल्स पैकेज (विकसित 2015)।

आर में सूची की समझ

आप यहांLC पैकेज पा सकते हैं ।

install.packages("devtools")
devtools::install_github("mailund/lc")

उदाहरण

> library(itertools); library(lc)
> lc(paste(x$index, x$value), x=as.list(enumerate(rnorm(5))), )
[[1]]
[1] "1 -0.715651978438808"

[[2]]
[1] "2 -1.35430822605807"

[[3]]
[1] "3 -0.162872340884235"

[[4]]
[1] "4 1.42909760816254"

[[5]]
[1] "5 -0.880755983937781"

जहां प्रोग्रामिंग सिंटैक्स अभी तक पाइथन के रूप में साफ और पॉलिश नहीं है, लेकिन कार्यात्मक रूप से काम कर रहा है और इसकी मदद की रूपरेखा है:

"सिंटैक्स निम्नानुसार है: lc (expr, list, predicates) जहां expr सूचियों में सभी तत्वों के लिए मूल्यांकन की जाने वाली कुछ अभिव्यक्ति है, जहाँ सूचियाँ एक या एक से अधिक नामित सूचियाँ होती हैं, जहाँ ये एक नाम और एक अभिव्यक्ति नाम द्वारा निर्दिष्ट की जाती हैं = list_expr, और जहाँ विधेय वे भाव हैं जिनका एक बूलियन मान के लिए मूल्यांकन किया जाना चाहिए। उदाहरण के लिए, सभी सम संख्याओं की एक सूची प्राप्त करने के लिए, एक सूची x से हम lc (x ** 2, x = x, x% लिख सकते हैं। % 2 == 0)। एलसी को कॉल का परिणाम एक सूची है, जो एक्सप्र में अभिव्यक्तियों से निर्मित एक सूची है, इनपुट सूची के सभी तत्वों के लिए जहां विधेय सत्य का मूल्यांकन करता है। "

जहाँ आप ध्यान दें कि आप उपर्युक्त उदाहरण में उदाहरण के लिए खाली छोड़ सकते हैं।

पायथन शैली के इटर्टूल और एन्यूमरेशन

आप आर के इटर्टूल का उपयोग कर सकते हैं जो अजगर के इटर्टूल से काफी मिलता जुलता है, आगे यहां क्रैन में है

library(itertools)

जहाँ वर्णित है

"पुनरावृति पैदा करने के लिए विभिन्न उपकरण, पायथन इटर्टूल मॉड्यूल में फ़ंक्शन के बाद कई पैटर्न, और अन्य 'स्नो' पैकेज में फ़ंक्शन के बाद पैटर्न किए गए।"

उदाहरण। गणना

> for (a in as.list(enumerate(rnorm(5)))) { print(paste(a$index, "index:", a$value))}
[1] "1 index: 1.63314811372568"
[1] "2 index: -0.983865948988314"
[1] "3 index: -1.27096072277818"
[1] "4 index: 0.313193212706331"
[1] "5 index: 1.25226639725357"

उदाहरण। ज़िप के साथ गणना

> for (h in as.list(izip(a=1:5, b=letters[1:5]))) { print(paste(h$a, "index:", h$b))}
[1] "1 index: a"
[1] "2 index: b"
[1] "3 index: c"
[1] "4 index: d"
[1] "5 index: e"

Question 7

zipऔर enumerateआर में लागू करने के लिए विशेष रूप से मुश्किल नहीं हैं:

#' zip(1:5,1:10)
zip <- function(...) {
  mapply(list, ..., SIMPLIFY = FALSE)
}

गणना करना सरल है zip:

#' enumerate(l=LETTERS)
enumerate <- function(...) {
  zip(ix=seq_along(..1), ...)
}

चूँकि ये उचित कार्य हैं, इसलिए हम ...इनका उपयोग काफी लचीला और सुव्यवस्थित बनाने के लिए कर सकते हैं , और mapply के व्यवहार का लाभ उठा सकते हैं, जैसे कि रिसाइकिलिंग इनपुट और नामकरण आउटपुट को सही ढंग से।

Question 8

# similar to python. return a list of list. Short sequences get recycled.
zip <- function(...){ 
    all.list <- list(...)
    ele.names <- names(all.list)
    max.length <- max(sapply(all.list, length))
    lapply(0:(max.length - 1), function(i) {
        res <- lapply(all.list, function(l) l[i %% length(l) + 1]) 
        names(res) <- ele.names
        res
    })
}

Question 9

यह दो पेस्ट स्टेटमेंट का उपयोग करके प्राप्त किया जा सकता है:

str1 <- paste(1:11, 10:20, sep=",", collapse='), (')
paste("(", str1, ")", sep = "")

उत्पादन निम्नलिखित की तरह होगा:

'(1,10), (2,11), (3,12), (4,13), (5,14), (6,15), (7,16), (8,17), (9,18), (10,19), (11,20)'

Question 10

अजगर के लिए, आर में समतुल्य 'एनुमरेट' सूची में वैक्टर को संचय करना और एक सूचकांक के साथ उन पर पुनरावृत्ति करना ठीक काम करना चाहिए।

vect1 <- c('A', 'B', 'C')
vect2 <- c('a', 'b', 'c')

# eqiv to zip values:
idx_list <- list(vect1, vect2)
idx_vect <- c(1:length(idx_list[[1]]))

for(i in idx_vect){
    x <- idx_list[[1]][i]
    j <- idx_list[[2]][i]
    print(c(i, x, j))
}

आउटपुट:

[1] "1" "A" "a"
[1] "2" "B" "b"
[1] "3" "C" "c"

आर 'सूची' वैक्टर जमा करने और एक सूचकांक के साथ बनाए रखने के लिए एक अच्छा बैंक है।