क्या मुझे डेटा.फ्रेम या मैट्रिक्स का उपयोग करना चाहिए?

Question

किसी को data.frame का उपयोग कब करना चाहिए, और matrix का उपयोग करना बेहतर क्यों है?

दोनों आयताकार प्रारूप में डेटा रखते हैं, इसलिए कभी-कभी यह अस्पष्ट है।

क्या डेटा प्रकार का उपयोग करने के लिए अंगूठे के कोई सामान्य नियम हैं?

Answer 1

उत्तर का हिस्सा पहले से ही आपके प्रश्न में निहित है: यदि कॉलम (चर) को विभिन्न प्रकारों (संख्यात्मक/चरित्र/तार्किक आदि) होने की उम्मीद की जा सकती है तो आप डेटा फ्रेम का उपयोग करते हैं। Matrices एक ही प्रकार के डेटा के लिए हैं।

नतीजतन, विकल्प मैट्रिक्स/डेटा.फ्रेम केवल समस्याग्रस्त है यदि आपके पास एक ही प्रकार का डेटा है।

उत्तर इस बात पर निर्भर करता है कि आप डेटा.फ्रेम/मैट्रिक्स में डेटा के साथ क्या करने जा रहे हैं। यदि यह अन्य कार्यों में पारित होने जा रहा है तो इन कार्यों के तर्कों की अपेक्षित प्रकार पसंद निर्धारित करती है।

इसके अलावा:

मैट्रिसेस अधिक स्मृति कुशल हैं:

m = matrix(1:4, 2, 2) 
d = as.data.frame(m) 
object.size(m) 
# 216 bytes 
object.size(d) 
# 792 bytes 

मैट्रिसेस एक आवश्यकता यदि आप आपरेशन के किसी भी रेखीय बीजगणित में टाइप करें करने की योजना है।

डेटा फ्रेम अधिक सुविधाजनक होते हैं यदि आप अक्सर नाम से कॉलम (कॉम्पैक्ट $ ऑपरेटर के माध्यम से) का संदर्भ लेते हैं।

डाटा फ्रेम भी रिपोर्टिंग (प्रिंटिंग) टैब्यूलर जानकारी के लिए आईएमएचओ बेहतर हैं क्योंकि आप प्रत्येक कॉलम को अलग से स्वरूपण लागू कर सकते हैं।

Answer 2

@ मिचल द्वारा उल्लिखित कुछ नहीं है कि मैट्रिस का उपयोग करके मैट्रिक्स समकक्ष डेटा फ्रेम से छोटा मैट्रिक्स न केवल डेटा फ्रेम का उपयोग करने से आपके कोड को और अधिक कुशल बना सकता है। यही कारण है कि आंतरिक रूप से, बहुत से आर फ़ंक्शन डेटा फ्रेम में मौजूद मैट्रिक्स डेटा को सह-प्रसारित करेंगे।

डेटा फ्रेम अक्सर अधिक सुविधाजनक होते हैं; किसी के पास हमेशा झूठ बोलने वाले डेटा के परमाणु भाग नहीं होते हैं।

ध्यान दें कि आपके पास एक चरित्र मैट्रिक्स हो सकता है; तुम सिर्फ आर

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

> head(as.matrix(data.frame(a = factor(letters), B = factor(LETTERS)))) 
    a B 
[1,] "a" "A" 
[2,] "b" "B" 
[3,] "c" "C" 
[4,] "d" "D" 
[5,] "e" "E" 
[6,] "f" "F" 
> head(data.matrix(data.frame(a = factor(letters), B = factor(LETTERS)))) 
    a B 
[1,] 1 1 
[2,] 2 2 
[3,] 3 3 
[4,] 4 4 
[5,] 5 5 
[6,] 6 6 

मैं लगभग हमेशा अपने डेटा विश्लेषण कार्यों के लिए एक डेटा फ्रेम का उपयोग के रूप में मैं अक्सर बस सांख्यिक चर की तुलना में अधिक है। जब मैं संकुल के लिए कोड फ़ंक्शन करता हूं, तो मैं लगभग हमेशा मैट्रिक्स पर सहभागिता करता हूं और फिर परिणामों को डेटा फ्रेम के रूप में वापस प्रारूपित करता हूं। ऐसा इसलिए है क्योंकि डेटा फ्रेम सुविधाजनक हैं।

Answer 3

मैट्रिक्स वास्तव में अतिरिक्त विधियों वाला एक वेक्टर है। जबकि data.frame एक सूची है। अंतर वेक्टर बनाम सूची में नीचे है। गणना दक्षता के लिए, मैट्रिक्स के साथ छड़ी। यदि आपको करना है तो डेटा.फ्रेम का उपयोग करना।

Answer 4

@Michal: मैट्रिसेस वास्तव में अधिक स्मृति कुशल नहीं हैं:

m <- matrix(1:400000, 200000, 2) 
d <- data.frame(m) 
object.size(m) 
# 1600200 bytes 
object.size(d) 
# 1600776 bytes 

... जब तक आप स्तंभों की एक बड़ी संख्या है:

m <- matrix(1:400000, 2, 200000) 
d <- data.frame(m) 
object.size(m) 
# 1600200 bytes 
object.size(d) 
# 22400568 bytes 

Answer 5

मैट्रिसेस और डेटा फ्रेम आयताकार हैं 2 डी arrays और पंक्तियों और स्तंभों द्वारा विषम हो सकता है। वे कुछ विधियों और गुण साझा करते हैं, लेकिन सभी नहीं।

उदाहरण:

M <- list(3.14,TRUE,5L,c(2,3,5),"dog",1i) # a list 
dim(M) <- c(2,3)       # set dimensions 
print(M)         # print result 

#  [,1] [,2]  [,3] 
# [1,] 3.14 5   "dog" 
# [2,] TRUE Numeric,3 0+1i 

DF <- data.frame(M)     # a data frame 
print(DF)        # print result 

#  X1  X2 X3 
# 1 3.14  5 dog 
# 2 TRUE 2, 3, 5 0+1i 

M <- matrix(c(1,1,1,1,2,3,1,3,6),3) # a numeric matrix 
DF <- data.frame(M)     # a all numeric data frame 

solve(M)        # obtains inverse matrix 
solve(DF)        # obtains inverse matrix 
det(M)        # obtains determinant 
det(DF)        # error