आर में सूचियों का सही उपयोग कैसे करें?

Question

संक्षिप्त पृष्ठभूमि: कई (अधिकांश?) समकालीन प्रोग्रामिंग भाषाओं में व्यापक उपयोग में कम से कम ADTs [अमूर्त डेटा प्रकार] की एक मुट्ठी भर है, विशेष रूप से,

• स्ट्रिंग (एक अनुक्रम जिसमें वर्ण शामिल हैं)

• सूची (मूल्यों का आदेश दिया गया संग्रह), और

• मानचित्र-आधारित प्रकार (मानों की कुंजियाँ प्रदर्शित करने वाला एक अनियंत्रित सरणी)

आर प्रोग्रामिंग भाषा में, पहले दो को क्रमशः characterऔर vector, के रूप में लागू किया जाता है।

जब मैंने आर सीखना शुरू किया, तो शुरू से ही दो चीजें लगभग स्पष्ट थीं: listआर में सबसे महत्वपूर्ण डेटा प्रकार है (क्योंकि यह आर के लिए मूल वर्ग है data.frame), और दूसरा, मैं अभी समझ नहीं पाया कि उन्होंने कैसे काम किया, कम से कम मेरे कोड में उन्हें सही ढंग से उपयोग करने के लिए पर्याप्त नहीं है।

एक बात के लिए, यह मुझे लग रहा था कि आर का listडेटा टाइप एडीटी ( dictionaryपायथन में, NSMutableDictionaryऑब्जेक्टिव सी में, hashपर्ल और रूबी में, object literalजावास्क्रिप्ट में, और इसके आगे) मैप का एक सीधा कार्यान्वयन था ।

उदाहरण के लिए, आप उन्हें वैसे ही बनाते हैं, जैसे आप एक पायथन डिक्शनरी को, एक कंस्ट्रक्टर को की-वैल्यू पेयर पास करके (जो पायथन में dictनहीं है list):

x = list("ev1"=10, "ev2"=15, "rv"="Group 1")

और आप आर लिस्ट की वस्तुओं को वैसे ही एक्सेस करते हैं जैसे आप पायथन डिक्शनरी के होते हैं, जैसे x['ev1'],। इसी तरह, आप केवल 'कुंजियाँ' या 'मूल्यों' को पुनः प्राप्त कर सकते हैं :

names(x)    # fetch just the 'keys' of an R list
# [1] "ev1" "ev2" "rv"

unlist(x)   # fetch just the 'values' of an R list
#   ev1       ev2        rv 
#  "10"      "15" "Group 1" 

x = list("a"=6, "b"=9, "c"=3)  

sum(unlist(x))
# [1] 18

लेकिन R lists अन्य मानचित्र-प्रकार ADTs (मैं वैसे भी सीखी गई भाषाओं में से) के विपरीत हैं । मेरा अनुमान है कि यह एस के लिए प्रारंभिक युक्ति का एक परिणाम है, अर्थात, एक डेटा / आँकड़े डीएसएल [डोमेन-विशिष्ट भाषा] को डिजाइन करने का इरादा है।

listव्यापक उपयोग में अन्य भाषाओं में R s और मैपिंग प्रकारों के बीच तीन महत्वपूर्ण अंतर (जैसे, पायथन, पर्ल, जावास्क्रिप्ट):

listआर में पहले , s एक ऑर्डर किए गए संग्रह हैं, वैक्टर की तरह, भले ही मानों को कुंजीबद्ध किया गया हो (यानी, चाबियाँ किसी भी हैशनेबल मूल्य हो सकती हैं न कि केवल अनुक्रमिक पूर्णांक)। लगभग हमेशा, अन्य भाषाओं में डेटा प्रकार मैपिंग अनियंत्रित है ।

दूसरा , listरों कार्यों भले ही आप एक में पारित कर दिया कभी नहीं से लौटाया जा सकता listहै जब आप समारोह कहा जाता है, और भले ही समारोह है कि लौटे listएक (स्पष्ट) शामिल नहीं है list(निर्माता बेशक, आप इस के साथ व्यवहार में से निपट सकते हैं कॉल में दिए गए परिणाम को लपेटकर unlist):

x = strsplit(LETTERS[1:10], "")     # passing in an object of type 'character'

class(x)                            # returns 'list', not a vector of length 2
# [1] list

आर के एस की एक तीसरी अजीब विशेषता list: ऐसा नहीं लगता है कि वे एक और एडीटी के सदस्य हो सकते हैं, और यदि आप ऐसा करने की कोशिश करते हैं, तो प्राथमिक कंटेनर एक के लिए मजबूर है list। उदाहरण के लिए,

x = c(0.5, 0.8, 0.23, list(0.5, 0.2, 0.9), recursive=TRUE)

class(x)
# [1] list

यहाँ मेरा इरादा भाषा की आलोचना या इसे कैसे प्रलेखित करना है; इसी तरह, मैं सुझाव नहीं दे रहा हूं कि listडेटा संरचना के साथ कुछ गलत है या यह कैसे व्यवहार करता है। मेरे पास सब कुछ सही होने के बारे में मेरी समझ है कि वे कैसे काम करते हैं इसलिए मैं अपने कोड में उनका सही उपयोग कर सकता हूं।

यहाँ उन चीज़ों के बारे में बताया गया है जिन्हें मैं बेहतर समझना चाहता हूँ:

• वे कौन से नियम हैं जो निर्धारित करते हैं कि फ़ंक्शन कॉल कब लौटेगी list(उदाहरण के लिए, strsplitऊपर सुनाई गई अभिव्यक्ति)?

• अगर मैं स्पष्ट रूप से list(जैसे list(10,20,30,40)) नामों को निर्दिष्ट नहीं करता हूं, तो क्या डिफ़ॉल्ट नाम सिर्फ 1 से शुरू होने वाले अनुक्रमिक पूर्णांक हैं? (मुझे लगता है, लेकिन मैं इस बात से बहुत दूर हूं कि इसका उत्तर हां में है, अन्यथा हम इस प्रकार के listवेक्टर w / / के लिए कॉल करने में सक्षम नहीं होंगे unlist।

• ये दो अलग-अलग ऑपरेटर [], और [[]], एक ही परिणाम क्यों लौटाते हैं ?

  x = list(1, 2, 3, 4)

  दोनों अभिव्यक्तियाँ "1":

  x[1]

  x[[1]]

• ये दोनों भाव एक ही परिणाम क्यों नहीं देते हैं?

  x = list(1, 2, 3, 4)

  x2 = list(1:4)

कृपया मुझे आर डॉक्युमेंटेशन ( ?list, R-intro) की ओर इशारा न करें - मैंने इसे ध्यान से पढ़ा है और इससे मुझे उन प्रश्नों के उत्तर देने में मदद नहीं मिलती है, जो मैंने अभी-अभी पढ़े हैं।

(अंत में, मैंने हाल ही में आर 4 पैकेज (सीआरएएन पर उपलब्ध) का उपयोग करना शुरू किया, जिसे एक एस 4 वर्ग के माध्यम से पारंपरिक मानचित्र-प्रकार के व्यवहार को hashलागू करता है ; मैं निश्चित रूप से इस पैकेज की सिफारिश कर सकता हूं।)

Comments

इसके साथ x = list(1, 2, 3, 4), ये दोनों एक ही परिणाम नहीं देते हैं: x[1]और x[[1]]। पहला एक सूची देता है और दूसरा एक संख्यात्मक वेक्टर देता है। नीचे स्क्रॉल करते हुए मुझे प्रतीत होता है कि डिर्क इस प्रश्न को सही ढंग से संबोधित करने के लिए एकमात्र प्रतिवादी था।

— IRTFM

मैंने किसी को भी अपने तरीके के विस्तार पर ध्यान नहीं दिया कि listR एक हैश की तरह नहीं है। मेरे पास एक और है जो मुझे लगता है कि ध्यान देने योग्य है। listR में एक ही संदर्भ नाम के साथ दो सदस्य हो सकते हैं। इस बात पर विचार करें कि obj <- c(list(a=1),list(a=2))यह मान्य है और 'a' के दो नामित मूल्यों के साथ एक सूची देता है। इस उदाहरण में कॉल के लिए obj["a"]केवल पहला मिलान सूची तत्व वापस आ जाएगा। आप x <- new.env(); x[["a"]] <- 1; x[["a"]] <- 2; x[["a"]]

— आरएच

मैंने पिछले 6 महीनों में तीन बार उत्तरों के साथ इस पोस्ट को फिर से पढ़ा है और हर बार अधिक ज्ञान पाया। शानदार सवाल और कुछ बेहतरीन जवाब। धन्यवाद।

— रिच लाइसाकोव्स्की पीएचडी

Answer 1

बस अपने प्रश्न के अंतिम भाग को संबोधित करने के लिए, क्योंकि वास्तव में आर listऔर ए के बीच के अंतर को इंगित करता है vector:

ये दोनों भाव समान परिणाम क्यों नहीं लौटाते?

x = सूची (1, 2, 3, 4); x2 = सूची (1: 4)

एक सूची में प्रत्येक तत्व के रूप में कोई अन्य वर्ग हो सकता है। तो आपके पास एक सूची हो सकती है जहां पहला तत्व एक चरित्र वेक्टर है, दूसरा एक डेटा फ्रेम है, आदि। इस मामले में, आपने अलग-अलग सूची बनाई है। xचार वैक्टर हैं, प्रत्येक की लंबाई 1 x2है। 1 वेक्टर की लंबाई 4 है:

> length(x[[1]])
[1] 1
> length(x2[[1]])
[1] 4

तो ये पूरी तरह से अलग सूची हैं।

आर सूचियाँ हैश मैप डेटा संरचना की तरह होती हैं जिसमें प्रत्येक सूचकांक मूल्य किसी भी वस्तु से जुड़ा हो सकता है। यहां एक सूची का एक सरल उदाहरण दिया गया है जिसमें 3 अलग-अलग वर्ग (एक फ़ंक्शन सहित) हैं:

> complicated.list <- list("a"=1:4, "b"=1:3, "c"=matrix(1:4, nrow=2), "d"=search)
> lapply(complicated.list, class)
$a
[1] "integer"
$b
[1] "integer"
$c
[1] "matrix"
$d
[1] "function"

यह देखते हुए कि अंतिम तत्व खोज फ़ंक्शन है, मैं इसे इस तरह कह सकता हूं:

> complicated.list[["d"]]()
[1] ".GlobalEnv" ...

इस पर अंतिम टिप्पणी के रूप में: यह ध्यान दिया जाना चाहिए कि data.frameयह वास्तव में एक सूची है ( data.frameप्रलेखन से):

एक डेटा फ्रेम अद्वितीय पंक्ति नामों वाली समान पंक्तियों के चर की एक सूची है, जिसे '' data.frame '' श्रेणी दी गई है।

इसीलिए किसी कॉलम में data.frameअलग-अलग प्रकार के डेटा हो सकते हैं, जबकि मैट्रिक्स में कॉलम नहीं हो सकते। एक उदाहरण के रूप में, यहां मैं संख्याओं और वर्णों के साथ एक मैट्रिक्स बनाने की कोशिश करता हूं:

> a <- 1:4
> class(a)
[1] "integer"
> b <- c("a","b","c","d")
> d <- cbind(a, b)
> d
 a   b  
[1,] "1" "a"
[2,] "2" "b"
[3,] "3" "c"
[4,] "4" "d"
> class(d[,1])
[1] "character"

ध्यान दें कि मैं पहले कॉलम में डेटा प्रकार को संख्यात्मक में नहीं बदल सकता क्योंकि दूसरे कॉलम में वर्ण हैं:

> d[,1] <- as.numeric(d[,1])
> class(d[,1])
[1] "character"

Comments

यह मदद करता है, धन्यवाद। (वैसे, आपका उदाहरण फिर से 'जटिल सूची' है, जैसा कि आप पहले से ही जानते हैं, सी + +, जावा आदि में 'स्विच' स्टेटमेंट को उन भाषाओं में दोहराने का मानक तरीका है जिनमें एक नहीं है; शायद एक अच्छा तरीका है; आर में ऐसा करने के लिए जब मुझे आवश्यकता हो)। +1

— डग 23

हालांकि, switchआर में एक उपयोगी फ़ंक्शन है जो उस उद्देश्य के लिए उपयोग किया जा सकता है (देखें help(switch))।

— शेन

Answer 2

अपने प्रश्नों के बारे में, मुझे उन्हें क्रम में संबोधित करने और कुछ उदाहरण देने दें:

1 ) एक सूची लौटा दी जाती है अगर और जब वापसी विवरण एक जोड़ता है। विचार करें

 R> retList <- function() return(list(1,2,3,4)); class(retList())
 [1] "list"
 R> notList <- function() return(c(1,2,3,4)); class(notList())
 [1] "numeric"
 R> 

2 ) नाम बस निर्धारित नहीं हैं:

R> retList <- function() return(list(1,2,3,4)); names(retList())
NULL
R> 

3 ) वे एक ही चीज नहीं लौटाते। आपका उदाहरण देता है

R> x <- list(1,2,3,4)
R> x[1]
[[1]]
[1] 1
R> x[[1]]
[1] 1

जहाँ - x[1]का पहला तत्व है x, जो कि जैसा है वैसा ही लौटाता है x। हर स्केलर लंबाई का एक वेक्टर है। दूसरी ओर x[[1]]सूची का पहला तत्व देता है।

4 ) अंत में, दो उनके बीच अलग-अलग होते हैं, क्रमशः, एक सूची जिसमें चार स्केलर होते हैं और एक तत्व के साथ एक सूची होती है (जो कि चार तत्वों का एक वेक्टर होता है)।

Comments

बहुत मददगार, धन्यवाद। (आपके उत्तर में पुन: आइटम # 1 - मैं सहमत हूं, लेकिन जो मेरे मन में था वह 'strsplit' की तरह बनाया गया था, न कि उपयोगकर्ता द्वारा बनाए गए कार्य)। किसी भी घटना में, मेरी ओर से +1।

— doug

@doug आइटम # 1 के बारे में मुझे लगता है कि विशिष्ट कार्य, अनुभाग के लिए मदद की जांच करना एकमात्र तरीका है Value। जैसे ?strsplit: "x के समान लंबाई की एक सूची"। लेकिन आपको यह विचार करना चाहिए कि तर्कों पर निर्भर एक फ़ंक्शन रिटर्न विभिन्न मान हो सकता है (जैसे। नीलम सूची या वेक्टर वापस कर सकता है)।

— मर्क

Answer 3

बस अपने सवालों का एक सबसेट लेने के लिए:

अनुक्रमण पर यह लेख[] और के बीच के अंतर के सवाल को संबोधित करता है [[]]।

संक्षेप में [[]] एक सूची में से किसी एक आइटम का चयन करता है और []चयनित वस्तुओं की सूची देता है। आपके उदाहरण में, x = list(1, 2, 3, 4)'आइटम 1 एक पूर्णांक है, लेकिन x[[1]]एक एकल 1 x[1]लौटाता है और केवल एक मान के साथ एक सूची देता है।

> x = list(1, 2, 3, 4)
> x[1]
[[1]]
[1] 1

> x[[1]]
[1] 1

Comments

वैसे, समतल सरणी A = array( 11:16, c(2,3) ); A[5]में 15 है !

— डेनिस

Answer 4

एक कारण सूचियां काम करती हैं जैसा कि वे करते हैं (ऑर्डर किया गया) एक ऑर्डर किए गए कंटेनर की आवश्यकता को संबोधित करना है जिसमें किसी भी नोड पर कोई भी प्रकार हो सकता है, जो वैक्टर नहीं करते हैं। आर में विभिन्न उद्देश्यों के लिए सूचियों का पुन: उपयोग किया जाता है, जिसमें एक का आधार बनाना शामिल है data.frame, जो कि मनमाने प्रकार के वैक्टर (लेकिन समान लंबाई) की एक सूची है।

ये दोनों भाव समान परिणाम क्यों नहीं लौटाते?

x = list(1, 2, 3, 4); x2 = list(1:4)

@ शेन के उत्तर में जोड़ने के लिए, यदि आप एक ही परिणाम प्राप्त करना चाहते हैं, तो प्रयास करें:

x3 = as.list(1:4)

जो वेक्टर 1:4को एक सूची में ले जाता है।

Answer 5

बस इस में एक और बिंदु जोड़ने के लिए:

आर एक डेटा संरचना में अजगर dict के बराबर है पैकेज । आप इसके बारे में इस ब्लॉग पोस्ट में Open Data Group से पढ़ सकते हैं । यहाँ एक सरल उदाहरण दिया गया है:hash

> library(hash)
> h <- hash( keys=c('foo','bar','baz'), values=1:3 )
> h[c('foo','bar')]
<hash> containing 2 key-value pairs.
  bar : 2
  foo : 1

प्रयोज्य के संदर्भ में, hashवर्ग एक सूची के समान है। लेकिन बड़े डेटासेट के लिए प्रदर्शन बेहतर है।

Comments

मुझे हैश पैकेज के बारे में पता है - यह मेरे मूल प्रश्न में पारंपरिक हैश प्रकार के लिए उपयुक्त प्रॉक्सी के रूप में उल्लिखित है।

— doug

यह भी ध्यान दें कि हैश :: हैश का उपयोग हैशेड वातावरण, rpubs.com/rpierce/hashBenchmark के सापेक्ष संदिग्ध उपयोगिता का है ।

— russellpierce

Answer 6

तुम कहो:

दूसरे के लिए, सूचियों को फ़ंक्शन से वापस किया जा सकता है, भले ही आप कभी भी एक सूची में पारित नहीं हुए जब आप फ़ंक्शन को बुलाते हैं, और भले ही फ़ंक्शन में कोई सूची निर्माता शामिल न हो, उदा।

x = strsplit(LETTERS[1:10], "") # passing in an object of type 'character'
class(x)
# => 'list'

और मुझे लगता है कि आप सुझाव देते हैं कि यह एक समस्या है (?)। मैं यहां आपको बता रहा हूं कि यह समस्या क्यों नहीं है :-)। आपका उदाहरण थोड़ा सरल है, इसमें जब आप स्ट्रिंग-विभाजन करते हैं, तो आपके पास उन तत्वों के साथ एक सूची होती है जो 1 तत्व लंबे होते हैं, इसलिए आपको पता है कि x[[1]]जैसा है वैसा ही है unlist(x)[1]। लेकिन क्या होगा अगर strsplitप्रत्येक बिन में अलग-अलग लंबाई के परिणाम लौटे। बस एक सदिश (बनाम एक सूची) लौटाना बिल्कुल नहीं होगा।

उदाहरण के लिए:

stuff <- c("You, me, and dupree",  "You me, and dupree",
           "He ran away, but not very far, and not very fast")
x <- strsplit(stuff, ",")
xx <- unlist(strsplit(stuff, ","))

पहले मामले में ( x: जो एक सूची लौटाता है), आप बता सकते हैं कि 3rd स्ट्रिंग का दूसरा "भाग" क्या था, जैसे x[[3]][2]:। xxअब आप इसका उपयोग कैसे कर सकते हैं कि परिणाम "अप्रकाशित" ( unlist-ed) हो गए हैं?

Answer 7

x = list(1, 2, 3, 4)
x2 = list(1:4)
all.equal(x,x2)

समान नहीं है क्योंकि 1: 4 c (1,2,3,4) के समान है। यदि आप चाहते हैं कि वे समान हों:

x = list(c(1,2,3,4))
x2 = list(1:4)
all.equal(x,x2)

Answer 8

यह एक बहुत पुराना प्रश्न है, लेकिन मुझे लगता है कि एक नए उत्तर के बाद से कुछ मूल्य हो सकते हैं, मेरी राय में, किसी ने ओपी में कुछ चिंताओं को सीधे संबोधित नहीं किया।

स्वीकार किए गए उत्तर क्या बताते हैं, इसके बावजूद listआर में ऑब्जेक्ट्स हैश मैप नहीं हैं । यदि आप अजगर के साथ एक समानांतर बनाना चाहते listहैं, तो अधिक पसंद कर रहे हैं, आप अनुमान लगाते हैं, अजगर listएस (या tupleवास्तव में है)।

यह वर्णन करना बेहतर है कि अधिकांश आर वस्तुओं को आंतरिक रूप से कैसे संग्रहीत किया जाता है (सी प्रकार का आर ऑब्जेक्ट है SEXP)। वे मूल रूप से तीन भागों से बने होते हैं:

• एक हेडर, जो ऑब्जेक्ट के आर प्रकार, लंबाई और कुछ अन्य मेटा डेटा की घोषणा करता है;
• डेटा भाग, जो एक मानक C हीप-आवंटित सरणी (मेमोरी का सन्निहित ब्लॉक) है;
• विशेषताएँ, जो अन्य आर ऑब्जेक्ट्स (या NULLयदि ऑब्जेक्ट में विशेषताएँ नहीं हैं) के लिए संकेतकर्ताओं की एक नामित लिंक सूची हैं ।

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

x <- runif(10)
y <- list(runif(10), runif(3))

के लिए x:

• हेडर कहेगा कि प्रकार numeric( REALSXPसी-साइड में) है, लंबाई 10 और अन्य सामान है।
• डेटा पार्ट एक एरे होगा जिसमें 10 doubleमान होंगे।
• विशेषताएँ हैं NULL, क्योंकि ऑब्जेक्ट में कोई भी नहीं है।

के लिए y:

• हेडर कहेगा कि प्रकार list( VECSXPसी-साइड में) है, लंबाई 2 और अन्य सामान है।
• डेटा भाग एक सरणी होगी जिसमें दो SEXP प्रकार होते हैं, क्रमशः runif(10)और प्राप्त मूल्य की ओर इशारा करते runif(3)हैं।
• गुण हैं NULLके लिए के रूप में, x।

तो एक numericवेक्टर और एक के बीच एकमात्र अंतर listयह है कि numericडेटा भाग doubleमूल्यों से बना है , जबकि listडेटा भाग के लिए अन्य आर ऑब्जेक्ट्स के लिए एक सरणी है।

नामों से क्या होता है? वैसे, नाम कुछ ऐसी विशेषताएँ हैं, जिन्हें आप किसी ऑब्जेक्ट को असाइन कर सकते हैं। आइए नीचे दी गई वस्तु देखें:

z <- list(a=1:3, b=LETTERS)

• हेडर कहेगा कि प्रकार list( VECSXPसी-साइड में) है, लंबाई 2 और अन्य सामान है।
• डेटा भाग एक सरणी होगी जिसमें दो SEXP प्रकार होते हैं, क्रमशः 1:3और प्राप्त मूल्य की ओर इशारा करते LETTERSहैं।
• विशेषताएँ अब मौजूद हैं और एक namesघटक है जो characterमूल्य के साथ एक आर ऑब्जेक्ट है c("a","b")।

आर स्तर से, आप attributesफ़ंक्शन के साथ किसी ऑब्जेक्ट की विशेषताओं को पुनः प्राप्त कर सकते हैं ।

R में हैश मैप का विशिष्ट-मूल्य केवल एक भ्रम है। जब आप कहें:

z[["a"]]

ऐसा ही होता है:

• [[सबसेट समारोह कहा जाता है;
• फ़ंक्शन का तर्क ( "a") प्रकार का है character, इसलिए विधि को namesऑब्जेक्ट के गुण (यदि वर्तमान) से ऐसे मूल्य की खोज करने का निर्देश दिया जाता है z;
• यदि namesविशेषता नहीं है, NULLतो लौटा दिया गया है;
• यदि मौजूद है, तो "a"उसमें मूल्य खोजा जाता है। यदि "a"वस्तु का नाम नहीं है, NULLतो लौटा दिया जाता है;
• यदि मौजूद है, तो स्थिति निर्धारित की जाती है (उदाहरण में 1)। तो सूची का पहला तत्व वापस आ गया है, अर्थात के बराबर z[[1]]।

कुंजी-मूल्य खोज अप्रत्यक्ष है और हमेशा स्थितीय है। इसके अलावा, ध्यान में रखना उपयोगी है:

• हैश मानचित्रों में केवल एक कुंजी की सीमा होनी चाहिए, वह यह है कि यह धोने योग्य होना चाहिए । namesआर में तार ( characterवैक्टर) होना चाहिए ;

• हैश मानचित्रों में आपके पास दो समान कुंजियाँ नहीं हो सकती हैं। आर में, आप namesबार-बार मानों के साथ किसी ऑब्जेक्ट को असाइन कर सकते हैं । उदाहरण के लिए:

  names(y) <- c("same", "same")

  आर में पूरी तरह से मान्य है। जब आप y[["same"]]पहले मान को पुनः प्राप्त करने का प्रयास करते हैं। आपको पता होना चाहिए कि इस बिंदु पर क्यों।

अंत में, किसी वस्तु को मनमाना गुण देने की क्षमता आपको बाहरी दृष्टिकोण से कुछ अलग दिखने का मौका देती है। लेकिन R lists किसी भी तरह से हैश मैप नहीं है।

Answer 9

वैक्टर और अन्य भाषाओं से हैश / सरणी अवधारणा के बारे में:

1. वैक्टर आर। एग, rpois(1e4,5)(5 रैंडम संख्या), numeric(55)(डबल्स पर लंबाई -55 शून्य वेक्टर) और character(12)(12 खाली स्ट्रिंग्स) के परमाणु हैं, सभी "मूल" हैं।

2. या तो सूची या वैक्टर हो सकते हैं names।

   > n = numeric(10)
   > n
    [1] 0 0 0 0 0 0 0 0 0 0
   > names(n)
   NULL
   > names(n) = LETTERS[1:10]
   > n
   A B C D E F G H I J 
   0 0 0 0 0 0 0 0 0 0

3. वैक्टर को एक ही डेटा प्रकार होने के लिए हर चीज की आवश्यकता होती है। इसे देखो:

   > i = integer(5)
   > v = c(n,i)
   > v
   A B C D E F G H I J           
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
   > class(v)
   [1] "numeric"
   > i = complex(5)
   > v = c(n,i)
   > class(v)
   [1] "complex"
   > v
      A    B    C    D    E    F    G    H    I    J                          
   0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i

4. सूचियों में अलग-अलग प्रकार के डेटा हो सकते हैं, जैसा कि अन्य उत्तरों में देखा जाता है और ओपी का प्रश्न ही होता है।

मैंने भाषाएं (माणिक, जावास्क्रिप्ट) देखी हैं, जिसमें "सरणियाँ" में चर डेटाटाइप हो सकते हैं, लेकिन उदाहरण के लिए C ++ में "सरणियाँ" सभी समान डेटाटाइप होनी चाहिए। मेरा मानना ​​है कि यह एक गति / दक्षता वाली बात है: यदि numeric(1e6)आपको पता है कि आपको इसका आकार और हर तत्व का स्थान एक प्राथमिकता है ; अगर बात "Flying Purple People Eaters"कुछ अज्ञात स्लाइस में हो सकती है , तो आपको वास्तव में इसके बारे में बुनियादी तथ्यों को जानने के लिए सामान को पार्स करना होगा।

जब कुछ प्रकार की गारंटी दी जाती है तो कुछ मानक आर ऑपरेशन भी अधिक मायने रखते हैं। उदाहरण के लिए cumsum(1:9)समझ में आता है, जबकि cumsum(list(1,2,3,4,5,'a',6,7,8,9))बिना गारंटी के, दोहरा होने की गारंटी देता है।

---

अपने दूसरे प्रश्न के रूप में:

फ़ंक्शन से लिस्ट वापस आ सकती हैं, भले ही आप कभी भी उस सूची में पास न हों जब आप फ़ंक्शन को कहते हैं

हर समय इनपुट की तुलना में फ़ंक्शंस विभिन्न डेटा प्रकारों को वापस करते हैं। plotहालांकि यह एक इनपुट के रूप में एक भूखंड नहीं लेता है, एक भूखंड देता है। Argएक रिटर्न numericहालांकि यह एक स्वीकार किए जाते हैं complex। आदि।

(और के रूप में strsplit: स्रोत कोड यहाँ है ।)

Answer 10

यह बहुत पुराना सवाल है, मुझे यह कहना चाहिए कि यह बिल्कुल ज्ञान को छू रहा है जिसे मैं आर में अपने पहले चरणों के दौरान याद कर रहा था - यानी कि आर में ऑब्जेक्ट के रूप में मेरे हाथ में डेटा कैसे व्यक्त किया जाए या मौजूदा वस्तुओं से कैसे चयन किया जाए। आर नौसिखिया के लिए शुरू से ही "एक आर बॉक्स में" सोचना आसान नहीं है।

इसलिए मैंने खुद नीचे बैसाखी का उपयोग करना शुरू कर दिया, जिससे मुझे यह पता लगाने में बहुत मदद मिली कि किस वस्तु का उपयोग करने के लिए क्या वस्तु है, और मूल रूप से वास्तविक उपयोग की कल्पना करने के लिए।

हालांकि मैं इस सवाल का सटीक जवाब नहीं दे रहा हूं कि नीचे दिया गया पाठ पाठक की मदद कर सकता है जो अभी आर के साथ शुरू हुआ है और सिम्मिलर सवाल पूछ रहा है।

• परमाणु वेक्टर ... मैंने अपने लिए "अनुक्रम" कहा, कोई दिशा नहीं, बस उसी प्रकार का अनुक्रम। [सबसेट।
• वेक्टर ... 2 डी से एक दिशा के साथ अनुक्रम, [सबसेट।
• मैट्रिक्स ... एक ही लंबाई वाले पंक्तियों या स्तंभों के साथ वैक्टरों का गुच्छा, [पंक्तियों और स्तंभों द्वारा उपसमुच्चय, या अनुक्रम द्वारा।
• Arrays ... 3 डी बनाने वाले स्तरित मैट्रीस
• डेटाफ्रेम ... एक्सेल की तरह एक 2 डी टेबल, जहां मैं पंक्तियों या स्तंभों को जोड़ या हटा सकता हूं या तर्क कर सकता हूं। उनके साथ संचालन, केवल कुछ समय बाद मैंने वास्तव में मान्यता दी कि डेटाफ्रेम एक चतुर कार्यान्वयन है listजहां मैं [पंक्तियों और स्तंभों का उपयोग करके उपसमुच्चय कर सकता हूं , लेकिन इसका उपयोग करना [[।
• सूची ... अपने आप को मदद करने के लिए मैंने सूची के बारे में सोचा कि tree structureकहां से [i]शाखाएं चुनती हैं और [[i]]शाखा से आइटम लौटाता है। और क्योंकि यह है tree like structure, तुम भी एक index sequenceका उपयोग कर सकते हैं एक बहुत ही जटिल पर हर पत्ती listका उपयोग इसके पते के लिए [[index_vector]]। सूचियाँ सरल या बहुत जटिल हो सकती हैं और विभिन्न प्रकार की वस्तुओं को एक में मिला सकती हैं।

तो listsआप के लिए और अधिक तरीके से समाप्त कर सकते हैं कि कैसे leafनिम्न उदाहरण में स्थिति के आधार पर चयन करें ।

l <- list("aaa",5,list(1:3),LETTERS[1:4],matrix(1:9,3,3))
l[[c(5,4)]] # selects 4 from matrix using [[index_vector]] in list
l[[5]][4] # selects 4 from matrix using sequential index in matrix
l[[5]][1,2] # selects 4 from matrix using row and column in matrix

इस तरह सोचने से मुझे बहुत मदद मिली।

Answer 11

यदि यह मदद करता है, तो मैं आर को "रिकॉर्ड" के रूप में "रिकॉर्ड" के रूप में अन्य पूर्व-ओओ भाषाओं में गर्भ धारण करता हूं:

• वे ओवररचिंग प्रकार के बारे में कोई धारणा नहीं बनाते हैं (या किसी भी प्रकार के सभी संभावित रिकॉर्ड और फ़ील्ड नामों के प्रकार उपलब्ध हैं)।
• उनके क्षेत्र अनाम हो सकते हैं (तब आप उन्हें सख्त परिभाषा क्रम द्वारा एक्सेस करते हैं)।

डेटाबेस रिकॉर्ड में "रिकॉर्ड" का अर्थ "रिकॉर्ड" (उर्फ पंक्तियों) के मानक अर्थ के साथ होगा, और यही कारण है कि उनका नाम खुद सुझाया गया: सूचियों (फ़ील्ड्स) के रूप में।

Answer 12

ये दो अलग-अलग ऑपरेटर क्यों [ ], और [[ ]], एक ही परिणाम लौटाते हैं?

x = list(1, 2, 3, 4)

1. [ ]उप सेटिंग ऑपरेशन प्रदान करता है। किसी भी वस्तु के सामान्य उप सेट में मूल वस्तु की तरह ही होगा। इसलिए, x[1] एक सूची प्रदान करता है। इसी तरह x[1:2]मूल सूची का एक सबसेट है, इसलिए यह एक सूची है। पूर्व।

   x[1:2]
   
   [[1]] [1] 1
   
   [[2]] [1] 2

2. [[ ]]सूची से एक तत्व निकालने के लिए है। x[[1]]मान्य है और सूची से पहला तत्व निकालें। x[[1:2]]के रूप में [[ ]] उप सेटिंग प्रदान नहीं करता है के रूप में मान्य नहीं है [ ]।

    x[[2]] [1] 2 
   
   > x[[2:3]] Error in x[[2:3]] : subscript out of bounds