ऐरे में

ऐरे के बारे में

R में list चीज़ों का एक ऐसा संग्रह है जिसमें क्रम बना रहता है, और यह कई मामलों में vectors से अलग होता है:

• इसमें रखी चीज़ें अलग-अलग टाइप की हो सकती हैं (जैसे numeric को character के साथ मिलाना)।
• इसमें रखी चीज़ें जटिल संरचनाएँ भी हो सकती हैं (जैसे वेक्टर, दूसरे ऐरे, आदि)।
• एलिमेंट तक पहुँचने का सिंटैक्स थोड़ा अलग होता है।

दूसरी भाषाओं से इसकी तुलना करना पूरी तरह ठीक नहीं बैठता। R का list कुछ हद तक Python की डिक्शनरी जैसा होता है, लेकिन इसमें क्रम बना रहता है और इसे संख्या वाले इंडेक्स से एक्सेस किया जा सकता है। यह C के struct जैसा भी कुछ-कुछ लगता है, बस फर्क यह है कि list को प्रोग्राम चलते समय आसानी से बढ़ाया जा सकता है।

ऐरे बनाना

वेक्टर की तुलना में ऐरे में एलिमेंट को नाम देना (जिन्हें अक्सर "टैग" कहा जाता है) ज़्यादा आम है:

list(x = 5.3, y = 4.2, color = "blue")
#> $x
#> [1] 5.3

#> $y
#> [1] 4.2

#> $color
#> [1] "blue"

लेकिन टैग देना ज़रूरी नहीं है, और तब R सिर्फ इंडेक्स संख्याएँ इस्तेमाल करता है:

list(5.3, 4.2, "blue")
#> [[1]]
#> [1] 5.3

#> [[2]]
#> [1] 4.2

#> [[3]]
#> [1] "blue"

ऐरे के एलिमेंट तक पहुँचना

ऐसा करने के तीन तरीके हैं, और हर तरीका अलग-अलग जगह काम आता है।

1. $tag नोटेशन से

जब टैग के नाम पहले से पता हों, तो यह बहुत आम है।

point <- list(x = 5.3, y = 4.2, color = "blue")
#> point$x
#> [1] 5.3
#> point$color
#> [1] "blue"

2. [[tag]] नोटेशन से

इसका फायदा यह है कि टैग का नाम प्रोग्राम चलते समय चुना जा सकता है। ध्यान दीजिए कि यहाँ ब्रैकेट दोहरे हैं।

want <- "y"
point[[want]] # same as point$y
#> [1] 4.2

3. पोज़िशन इंडेक्स से

यह तरीका तब भी काम करता है जब ऐरे में टैग हों, और तब भी जब न हों। यहाँ भी ब्रैकेट दोहरे हैं।

point[[3]] # same as point$color
#> [1] "blue"

एलिमेंट जोड़ना और हटाना

यह आसान है: किसी एलिमेंट को वैल्यू असाइन करने पर अगर वह एलिमेंट पहले से है तो उसकी वैल्यू बदल जाती है, और अगर नया है तो जुड़ जाता है।

point$color <- "red"
point$trust <- TRUE

# str() gives more compact output than the default display
str(point) 
#> List of 4
#>  $ x    : num 5.3
#>  $ y    : num 4.2
#>  $ color: chr "red"
#>  $ trust: logi TRUE

किसी एलिमेंट को हटाने के लिए उस अनचाहे एलिमेंट को NULL असाइन कीजिए।

point$trust <- NULL
str(point)  
#> List of 3
#>  $ x    : num 5.3
#>  $ y    : num 4.2
#>  $ color: chr "red"

ऐरे "रिकर्सिव वेक्टर" होते हैं

vector क्लास को तकनीकी रूप से atomic vector कहा जाता है, क्योंकि वह केवल एटॉमिक वैल्यू ही रख सकती है: numeric, character, boolean, आदि। चूँकि एक list में दूसरे ऐरे भी रह सकते हैं, इसलिए इसे recursive vector भी कहा जाता है।

यह केवल नामकरण की तकनीकी बात नहीं है, बल्कि यह भी याद दिलाता है कि ऐरे की संरचना मनमाने ढंग से जटिल हो सकती है। किसी ऐरे के एलिमेंट को एक्सेस करते समय क्या मिलेगा, यह समझना प्रोग्रामर की ज़िम्मेदारी है।

ऐरे की इंडेक्सिंग पर कुछ और

ऊपर कुछ उदाहरणों में ऐरे के एलिमेंट तक पहुँचने के लिए दोहरे ब्रैकेट [[ ]] इस्तेमाल हुए थे। यह एलिमेंट को समतल करके उसके मूल टाइप में बदलने की कोशिश करता है, जो तब काम आता है जब आपको सिर्फ एक संख्या या एक स्ट्रिंग चाहिए हो।

एकेले ब्रैकेट [ ] इस्तेमाल करने पर यह समतल करना नहीं होता, और जो वैल्यू लौटती है वह एक सबलिस्ट होती है।

point[["color"]]
#> [1] "red"  # flattened

point["color"]
#> $color
#> [1] "red"  # sublist

भले ही शुरुआती R प्रोग्रामर को सबलिस्ट न चाहिए हो, फिर भी इसके बारे में जानना ज़रूरी है। ज़्यादा से ज़्यादा लचीलेपन के लिए R के कई मानक फंक्शन list लौटाते हैं, भले ही उसमें यहाँ की तरह एक ही एटॉमिक वैल्यू हो।

किसी वेक्टर में बदलने के दो तरीके हैं।

1. [[1]] से पहला एलिमेंट निकालिए
2. unlist() फंक्शन इस्तेमाल कीजिए।

pt <-point["color"]

pt[[1]]
#> [1] "red" # simple 1-element vector

unlist(pt)
#> color 
#> "red"  # 1-element vector with name

unlist() के साथ सावधान रहिए। इस आसान मामले में संरचना को समतल करना काम आता है, लेकिन जटिल ऐरे एलिमेंट के साथ यह अचानक मुश्किलें खड़ी कर सकता है।