R Language
subsetting

परिचय

टिप्पणियों

x <- 1:3
x[NA]
## [1] NA NA NA

x[as.integer(NA)]
## [1] NA

x[c(NA, 1, NA, NA)]
## [1] NA  1 NA NA

(1:3)[10]
## [1] NA
(1:3)[[10]]
## Error in (1:3)[[10]] : subscript out of bounds
as.matrix(1:3)[10]
## [1] NA
as.matrix(1:3)[, 10]
## Error in as.matrix(1:3)[, 10] : subscript out of bounds
list(1, 2, 3)[10]
## [[1]]
## NULL
list(1, 2, 3)[[10]]
## Error in list(1, 2, 3)[[10]] : subscript out of bounds

c(a = 1, b = 2)["c"]
## <NA> 
##   NA 
list(a = 1, b = 2)["c"]
## <NA>
## NULL

परमाणु वैक्टर

परमाणु वैक्टर (जो सूचियों और अभिव्यक्तियों को शामिल करता है, जो वैक्टर भी हैं) [ संचालक:

# create an example vector
v1 <- c("a", "b", "c", "d")

# select the third element
v1[3]
## [1] "c"

[ ऑपरेटर तर्क के रूप में एक वेक्टर भी ले सकता है। उदाहरण के लिए, पहले और तीसरे तत्वों का चयन करने के लिए:

v1 <- c("a", "b", "c", "d")

v1[c(1, 3)]
## [1] "a" "c"

कुछ बार हमें वेक्टर से एक विशेष मूल्य को छोड़ना पड़ सकता है। यह उस मूल्य के सूचकांक से पहले एक नकारात्मक चिह्न ( - ) का उपयोग करके प्राप्त किया जा सकता है। उदाहरण के लिए, v1 से पहले मान को छोड़ने के लिए, v1[-1] उपयोग करें। इसे सीधे फॉरवर्ड तरीके से एक से अधिक मूल्य तक बढ़ाया जा सकता है। उदाहरण के लिए, v1[-c(1,3)] ।

> v1[-1]
[1] "b" "c" "d"
> v1[-c(1,3)]
[1] "b" "d"

कुछ अवसरों पर, हम जानना चाहते हैं, विशेष रूप से, जब वेक्टर की लंबाई बड़ी होती है, एक विशेष मूल्य का सूचकांक, यदि यह मौजूद है:

> v1=="c"
[1] FALSE FALSE  TRUE FALSE
> which(v1=="c")
[1] 3

यदि परमाणु वेक्टर में नाम (एक names विशेषता) है, तो यह नामों के वर्ण वेक्टर का उपयोग करके सबसेट हो सकता है:

v <- 1:3
names(v) <- c("one", "two", "three")

v
##  one   two three 
##    1     2     3 

v["two"]
## two 
##   2

[[ संचालक का उपयोग परमाणु वैक्टरों को अनुक्रमित करने के लिए भी किया जा सकता है, इसमें अंतर यह है कि यह एक अनुक्रमण वेक्टर को एक की लंबाई के साथ स्वीकार करता है और किसी भी नाम को प्रस्तुत करता है:

v[[c(1, 2)]]
## Error in v[[c(1, 2)]] : 
##  attempt to select more than one element in vectorIndex

v[["two"]]
## [1] 2

तार्किक वेक्टर का उपयोग करके वैक्टर को भी कम किया जा सकता है। संख्यात्मक और चरित्र वैक्टर साथ subsetting के विपरीत, तार्किक सबसेट के लिए इस्तेमाल किया वेक्टर, वेक्टर जिसका तत्वों निकाले जाते हैं की लंबाई के बराबर होने के लिए, इसलिए यदि एक तार्किक वेक्टर है y प्रयोग किया जाता है करने के लिए सबसेट x , यानी x[y] , अगर length(y) < length(x) तब y को मिलान length(x) लिए पुनर्नवीनीकरण किया जाएगा:

v[c(TRUE, FALSE, TRUE)]
##  one three 
##    1     3 

v[c(FALSE, TRUE)]  # recycled to 'c(FALSE, TRUE, FALSE)'
## two 
##   2 

v[TRUE]   # recycled to 'c(TRUE, TRUE, TRUE)'
##  one   two three 
##    1     2     3 

v[FALSE]   # handy to discard elements but save the vector's type and basic structure
## named integer(0)

सूचियाँ

एक सूची के साथ सबसेट हो सकता [ :

l1 <- list(c(1, 2, 3), 'two' = c("a", "b", "c"), list(10, 20))
l1
## [[1]]
## [1] 1 2 3
## 
## $two
## [1] "a" "b" "c"
##
## [[3]]
## [[3]][[1]]
## [1] 10
##
## [[3]][[2]]
## [1] 20

l1[1]
## [[1]]
## [1] 1 2 3

l1['two']
## $two
## [1] "a" "b" "c"

l1[[2]]
## [1] "a" "b" "c"

l1[['two']]
## [1] "a" "b" "c"

l1[2] के परिणाम पर ध्यान दें, अभी भी एक सूची है, [ ऑपरेटर एक सूची के तत्वों का चयन करता है, एक छोटी सूची लौटाता है। [[ ऑपरेटर सूची तत्व के प्रकार का एक ऑब्जेक्ट लौटाता है, सूची तत्वों को निकालता है।

तत्वों को संख्या या नाम के एक वर्ण स्ट्रिंग द्वारा अनुक्रमित किया जा सकता है (यदि यह मौजूद है)। कई तत्वों का चयन [ संख्याओं के सदिश या नामों के तार को पास करके किया जा सकता है। एक वेक्टर की length > 1 साथ अनुक्रमण length > 1 [ और [[ निर्दिष्ट तत्वों के साथ एक "सूची" लौटाता है और एक पुनरावर्ती सबसेट (यदि उपलब्ध हो), क्रमशः :

l1[c(3, 1)]
## [[1]]
## [[1]][[1]]
## [1] 10
## 
## [[1]][[2]]
## [1] 20
## 
## 
## [[2]]
## [1] 1 2 3

की तुलना में:

l1[[c(3, 1)]]
## [1] 10

जो इसके बराबर है:

l1[[3]][[1]]
## [1] 10

$ ऑपरेटर आपको केवल नाम से सूची तत्वों का चयन करने की अनुमति देता है, लेकिन [ और [[ विपरीत, उद्धरण की आवश्यकता नहीं है। Infix ऑपरेटर के रूप में, $ केवल एक ही नाम ले सकता है:

l1$two
## [1] "a" "b" "c"

इसके अलावा, $ ऑपरेटर डिफ़ॉल्ट रूप से आंशिक मिलान की अनुमति देता है:

l1$t
## [1] "a" "b" "c"

इसके विपरीत [[ जहां यह निर्दिष्ट करने की आवश्यकता है कि आंशिक मिलान की अनुमति है या नहीं:

l1[["t"]]
## NULL
l1[["t", exact = FALSE]]
## [1] "a" "b" "c"

options(warnPartialMatchDollar = TRUE) सेट करना options(warnPartialMatchDollar = TRUE) , एक "चेतावनी" दी जाती है जब $ साथ आंशिक मिलान होता है:

l1$t
## [1] "a" "b" "c"
## Warning message:
## In l1$t : partial match of 't' to 'two'

मैट्रिसेस

किसी ऑब्जेक्ट के प्रत्येक आयाम के लिए, [ ऑपरेटर एक तर्क लेता है। वैक्टर का एक आयाम है और एक तर्क है। मैट्रिक्स और डेटा फ़्रेम के दो आयाम होते हैं और दो तर्क लेते हैं, जिन्हें [i, j] रूप में दिया जाता है [i, j] जहाँ i पंक्ति है और j कॉलम है। इंडेक्सिंग 1 से शुरू होती है।

## a sample matrix
mat <- matrix(1:6, nrow = 2, dimnames = list(c("row1", "row2"), c("col1", "col2", "col3")))

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

mat[i,j] में तत्व है i वें पंक्ति, j मैट्रिक्स के मई के स्तंभ mat । उदाहरण के लिए, i का 2 मान और 1 का j मान दूसरी पंक्ति और मैट्रिक्स के पहले कॉलम में संख्या देता है। उस आयाम में सभी मानों को वापस करना i या j लौटाता है।

mat[ , 3]
## row1 row2 
##    5    6 

mat[1, ]
# col1 col2 col3 
#    1    3    5 

जब मैट्रिक्स में पंक्ति या स्तंभ नाम होते हैं (आवश्यक नहीं), इनका उपयोग सबसेट के लिए किया जा सकता है:

mat[ , 'col1']
# row1 row2 
#    1    2 

डिफ़ॉल्ट रूप से, यदि संभव हो तो एक सबसेट का परिणाम सरल हो जाएगा। यदि उपसमुच्चय में केवल एक आयाम है, जैसा कि ऊपर के उदाहरणों में दिया गया है, तो परिणाम द्वि-आयामी मैट्रिक्स के बजाय एक-आयामी वेक्टर होगा। यह डिफ़ॉल्ट के साथ ओवरराइड किया जा सकता drop = FALSE करने के लिए तर्क [ :

## This selects the first row as a vector
class(mat[1, ])
# [1] "integer"

## Whereas this selects the first row as a 1x3 matrix:
class(mat[1, , drop = F])
# [1] "matrix"

बेशक, आयामों को गिराया नहीं जा सकता है यदि चयन में दो आयाम हैं:

mat[1:2, 2:3]  ## A 2x2 matrix
#      col2 col3
# row1    3    5
# row2    4    6

उनके पदों द्वारा व्यक्तिगत मैट्रिक्स प्रविष्टियों का चयन करना

एक मैट्रिक्स से एन व्यक्तिगत तत्वों का चयन करने के लिए Nx2 मैट्रिक्स का उपयोग करना भी संभव है (जैसे कि एक समन्वय प्रणाली कैसे काम करती है)। यदि आप किसी वेक्टर में (1st row, 1st column), (1st row, 3rd column), (2nd row, 3rd column), (2nd row, 1st column) में मैट्रिक्स की प्रविष्टियाँ निकालना चाहते हैं, तो यह कर सकते हैं आसानी से उन मैट्रिक्स के साथ एक इंडेक्स मैट्रिक्स बनाकर और मैट्रिक्स को कम करने के लिए इसका उपयोग किया जा सकता है:

mat
#      col1 col2 col3
# row1    1    3    5
# row2    2    4    6

ind = rbind(c(1, 1), c(1, 3), c(2, 3), c(2, 1))
ind
#      [,1] [,2]
# [1,]    1    1
# [2,]    1    3
# [3,]    2    3
# [4,]    2    1

mat[ind]
# [1] 1 5 6 2

उपरोक्त उदाहरण में, ind मैट्रिक्स का 1 कॉलम mat में पंक्तियों को संदर्भित करता है, ind का दूसरा कॉलम mat में कॉलम को संदर्भित करता है।

डेटा फ्रेम

एक डेटा फ्रेम को एक छोटे डेटा फ़्रेम में सबमिट करने से सूची को पूरा करने के समान ही पूरा किया जा सकता है।

> df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)

> df3
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

> df3[1]   # Subset a variable by number
##   x
## 1 1
## 2 2
## 3 3

> df3["x"]   # Subset a variable by name 
##   x
## 1 1
## 2 2
## 3 3

> is.data.frame(df3[1])
## TRUE

> is.list(df3[1])
## TRUE

एक कॉलम वेक्टर में एक डेटाफ्रेम को तोड़कर डबल ब्रैकेट [[]] या डॉलर साइन ऑपरेटर $ का उपयोग करके पूरा किया जा सकता है।

> df3[[2]]    # Subset a variable by number using [[ ]]
## [1] "a" "b" "c"

> df3[["y"]]  # Subset a variable by name using [[ ]]
## [1] "a" "b" "c"

> df3$x    # Subset a variable by name using $
## [1] 1 2 3

> typeof(df3$x)
## "integer"

> is.vector(df3$x)
## TRUE

एक डेटा को दो आयामी मैट्रिक्स के रूप में प्रस्तुत करना i और j शब्दों का उपयोग करके पूरा किया जा सकता है।

> df3[1, 2]    # Subset row and column by number
## [1] "a"

> df3[1, "y"]  # Subset row by number and column by name
## [1] "a"

> df3[2, ]     # Subset entire row by number  
##   x y
## 2 2 b

> df3[ , 1]    # Subset all first variables 
## [1] 1 2 3

> df3[ , 1, drop = FALSE]
##   x
## 1 1
## 2 2
## 3 3

नोट: द्वारा subsetting j (स्तंभ) अकेले चर के अपने प्रकार के लिए सरल लेकिन द्वारा subsetting i अकेला रिटर्न एक data.frame , के रूप में विभिन्न चर विभिन्न प्रकार और वर्गों हो सकता है। FALSE करने के लिए drop पैरामीटर सेट करने से डेटा फ्रेम बना रहता है।

> is.vector(df3[, 2])
## TRUE

> is.data.frame(df3[2, ])
## TRUE

> is.data.frame(df3[, 2, drop = FALSE])
## TRUE

अन्य वस्तुएं

[ और [[ संचालक आदिम कार्य हैं जो सामान्य हैं। इसका मतलब यह है कि R में किसी भी वस्तु (विशेष रूप से isTRUE(is.object(x)) - के पास एक स्पष्ट "वर्ग" विशेषता है जब उप-निर्धारित होने पर अपना स्वयं का निर्दिष्ट व्यवहार हो सकता है; यानी [ और / या [[ लिए अपने स्वयं के तरीके हैं ।

उदाहरण के लिए, यह "data.frame" ( is.object(iris) ) ऑब्जेक्ट्स के साथ मामला है जहाँ [.data.frame और [[.data.frame विधियों को परिभाषित किया गया है और वे दोनों "मैट्रिक्स" [[.data.frame प्रदर्शित करने के लिए बने हैं। और "सूची" जैसी सब्मिटिंग। "डेटा.फ्रेम" को सब्मिट करते समय एक त्रुटि के साथ, हम देखते हैं कि, वास्तव में, एक कार्य [.data.frame को बुलाया गया था जब हम-उपयोग करते थे [ ।

iris[invalidArgument, ]
## Error in `[.data.frame`(iris, invalidArgument, ) : 
##   object 'invalidArgument' not found

वर्तमान विषय पर अधिक जानकारी के बिना, एक उदाहरण [ विधि:

x = structure(1:5, class = "myClass")
x[c(3, 2, 4)]
## [1] 3 2 4
'[.myClass' = function(x, i) cat(sprintf("We'd expect '%s[%s]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour\n", deparse(substitute(x)), deparse(substitute(i))))

x[c(3, 2, 4)]
## We'd expect 'x[c(3, 2, 4)]' to be returned but this a custom `[` method and should have a `?[.myClass` help page for its behaviour
## NULL

हम समान गैर-जेनेरिक .subset (और .subset2 लिए [[ ) का उपयोग करके [ प्रेषण विधि पार कर सकते हैं। यह विशेष रूप से उपयोगी और कुशल है जब हमारे अपने "वर्ग" को प्रोग्रामिंग करते हैं और हमारे "कक्षा" पर कुशलतापूर्वक गणना करते समय काम के unclass(x) - unclass(x) जैसे unclass(x) ) से बचना चाहते हैं (विधि प्रेषण और वस्तुओं की नकल से बचते हुए):

.subset(x, c(3, 2, 4))
## [1] 3 2 4

वेक्टर अनुक्रमण

इस उदाहरण के लिए, हम वेक्टर का उपयोग करेंगे:

> x <- 11:20
> x
 [1] 11 12 13 14 15 16 17 18 19 20

R vectors 1-indexed हैं, इसलिए उदाहरण के लिए x[1] 11 वापस आ जाएगा। ब्रैकेट ऑपरेटर को सूचकांकों के वेक्टर को पास करके हम x का उप-वेक्टर भी निकाल सकते हैं:

> x[c(2,4,6)]
[1] 12 14 16

यदि हम ऋणात्मक सूचकांकों का एक सदिश पास करते हैं, तो R, निर्दिष्ट सूचकांकों के साथ एक उप-वेक्टर लौटाएगा:

> x[c(-1,-3)]
[1] 12 14 15 16 17 18 19 20

हम ब्रैकेट ऑपरेटर को एक बूलियन वेक्टर भी पास कर सकते हैं, जिस स्थिति में यह निर्देशांक के अनुरूप एक उप-वेक्टर लौटाता है जहां अनुक्रमण वेक्टर TRUE :

> x[c(rep(TRUE,5),rep(FALSE,5))]
[1] 11 12 13 14 15 16

यदि अनुक्रमण वेक्टर वेक्टर की लंबाई से कम है, तो इसे दोहराया जाएगा, जैसे कि:

> x[c(TRUE,FALSE)]
[1] 11 13 15 17 19
> x[c(TRUE,FALSE,FALSE)]
[1] 11 14 17 20

एलीमेंटवाइज़ मैट्रिक्स ऑपरेशन

बता दें कि A और B एक ही आयाम के दो मैट्रेस हैं। ऑपरेटर + , - , / , * , ^ जब एक ही आयाम के मैट्रिक्स के साथ उपयोग किया जाता है, तो मैट्रिसेस के संगत तत्वों पर आवश्यक संचालन करते हैं और उसी आयाम के एक नए मैट्रिक्स को वापस करते हैं। इन कार्यों को आमतौर पर तत्व-वार संचालन के रूप में संदर्भित किया जाता है।

"सच्चे" मैट्रिक्स गुणन के लिए, जैसा कि रैखिक बीजगणित में देखा गया है, %*% उपयोग करें। उदाहरण के लिए, A का B के साथ गुणा है: A %*% B आयामी आवश्यकताओं हैं कि ncol() के A रूप में ही हो nrow() के B

मैट्रिस के साथ उपयोग किए जाने वाले कुछ कार्य