R में डेटा प्रकार

परिचय शुरू करने और R में विभिन्न डेटा प्रकारों के बारे में सीखने से पहले, आइए जल्दी से टर्मिनल और Jupyter Notebook दोनों पर R वातावरण सेट अप कर लें।

निम्न कमांड Mac ऑपरेटिंग सिस्टम के लिए है, जो आपके टर्मिनल पर R इंस्टॉल करेगा।

brew install r --build-from-source

इंस्टॉलेशन सफल हुआ है या नहीं, यह जाँचने के लिए बस टर्मिनल में R (बड़े अक्षर में) टाइप करें, और आप नीचे दिखाए अनुसार एक R सत्र में प्रवेश कर लेंगे।

अन्य ऑपरेटिंग सिस्टम पर इंस्टॉलेशन के लिए, निःसंकोच यह ट्यूटोरियल देखें।

अब Jupyter Notebook पर R प्रोग्रामिंग भाषा को एक कर्नेल के रूप में जोड़ते हैं। सुनिश्चित करें कि आपके सिस्टम पर Jupyter Notebook पहले से इंस्टॉल है।

अपने टर्मिनल पर जाएँ, R सत्र खोलें और नीचे दिए गए दो कमांड दर्ज करें, जो आपके Jupyter Notebook में R कर्नेल जोड़ देंगे।

install.packages('IRkernel')
IRkernel::installspec()

जब ऊपर दिए गए दोनों कमांड सफल हो जाएँ, तो टर्मिनल से Jupyter चलाएँ और नीचे दिखाए अनुसार R कर्नेल के साथ एक नोटबुक खोलें:

अब आप Jupyter Notebook पर अपना पहला R कोड लिखने के लिए पूरी तरह तैयार हैं।

परिचय

R का अधिकतम उपयोग करने के लिए, यह जानना और समझना बहुत महत्वपूर्ण है कि R में कौन-कौन से डेटा प्रकार और डेटा संरचनाएँ मौजूद हैं और वे कैसे काम करती हैं। ये लगभग सभी समस्याओं में, खासकर तब जब आप मशीन लर्निंग जैसी अत्यधिक डेटा-केंद्रित समस्याओं पर काम कर रहे होते हैं, अहम भूमिका निभाती हैं।

किसी प्रोग्रामिंग भाषा में हमें आम तौर पर सूचना स्टोर करने के लिए वेरिएबल्स की ज़रूरत होती है, जो integer, character, floating-point, boolean आदि हो सकते हैं। वेरिएबल का type पूरी तरह इस बात पर आधारित होता है कि वह किस तरह की जानकारी रखता है। यदि किसी वेरिएबल को integer असाइन किया गया है, तो उसका डेटा प्रकार int होगा। वेरिएबल्स मूल रूप से आरक्षित मेमोरी लोकेशन होते हैं जहाँ मान स्टोर किए जाते हैं। जैसे ही आप कोई वेरिएबल बनाते हैं, उसके लिए कुछ मेमोरी स्पेस आरक्षित हो जाता है।

किसी वेरिएबल के डेटा प्रकार के आधार पर, ऑपरेटिंग सिस्टम कुछ मेमोरी अलॉट करेगा। उदाहरण के लिए, R प्रोग्रामिंग में, एक वेरिएबल जो integer रखता है वह 4 बाइट मेमोरी और character के लिए 1 बाइट आरक्षित करेगा।

C, C++, और Java जैसी प्रोग्रामिंग भाषाओं में वेरिएबल्स को डेटा प्रकार के रूप में डिक्लेयर किया जाता है; जबकि Python और R में वेरिएबल्स एक object होते हैं। ऑब्जेक्ट्स मूल रूप से एक डेटा संरचना हैं जिनमें कुछ attributes और methods होते हैं, जो उन्हीं attributes पर लागू होते हैं।

R-objects या डेटा संरचनाओं के कई प्रकार होते हैं जिन पर इस ट्यूटोरियल में चर्चा की जाएगी, जैसे:

• Vectors

• Lists

• Matrices

• Arrays

• Factors

• Data Frames

आइए पहले उन कुछ बुनियादी डेटा प्रकारों को समझते हैं जिन पर R-objects बने होते हैं, जैसे Numeric, Integer, Character, Factor, और Logical।

• Numeric: जिन संख्याओं में दशमलव मान होता है या जो भिन्न के रूप में होती हैं, उनका डेटा प्रकार numeric होता है।

num <- 1.2
print(num)

[1] 1.2

आप class() कीवर्ड का उपयोग करके a का डेटा प्रकार देख सकते हैं।

class(num)

'numeric'

• Integer: जिन संख्याओं में दशमलव मान नहीं होता, उनका डेटा प्रकार integer होता है। हालाँकि, integer डेटा प्रकार बनाने के लिए आप स्पष्ट रूप से as.integer() का उपयोग करते हैं और वेरिएबल को आर्ग्युमेंट के रूप में पास करते हैं।

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'

• Character: जैसा कि नाम से स्पष्ट है, कोई अक्षर या उद्धरण चिह्नों में बंद अक्षरों का संयोजन R द्वारा character डेटा प्रकार माना जाता है। यह अक्षर या संख्याएँ दोनों हो सकते हैं।

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'

• Logical: वह वेरिएबल जिसका मान True या False हो सकता है, जैसे boolean, उसे logical वेरिएबल कहा जाता है।

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'

• Factor: यह वह डेटा प्रकार है जिसका उपयोग किसी गुणात्मक संबंध जैसे रंग, अच्छा और बुरा, कोर्स या मूवी रेटिंग्स आदि को दर्शाने के लिए किया जाता है। ये सांख्यिकीय मॉडलिंग में उपयोगी होते हैं।

इसे प्राप्त करने के लिए, आप c() फ़ंक्शन का उपयोग करेंगे, जो सभी तत्वों को मिलाकर एक वेक्टर (एक-आयामी) लौटाता है।

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

fac फैक्टर में good, bad और ugly के तीन स्तर हैं, जिन्हें levels कीवर्ड से जाँचा जा सकता है, और स्तर का प्रकार character होगा।

levels(fac)

1. 'bad'
2. 'good'
3. 'ugly'

nlevels(fac)

3

class(levels(fac))

'character'

आगे बढ़ने से पहले, दो महत्वपूर्ण टिप्स समझ लेते हैं जो बहुत काम आ सकती हैं!

• हमेशा याद रखें कि R प्रोग्रामिंग भाषा case-sensitive है। ऊपर परिभाषित सभी ऑब्जेक्ट्स का उपयोग उसी तरह करें, चाहे upper हो या lower, जैसा कि नीचे दिए उदाहरण में दिखाया गया है।

Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:

• R में आप कार्य परिवेश (working environment) में आपने जो भी वेरिएबल/ऑब्जेक्ट्स परिभाषित किए हैं, उन्हें ls() कीवर्ड के जरिए देख सकते हैं, जैसा नीचे दिखाया गया है।

ls()

1. 'char'
2. 'int'
3. 'num'

लिस्ट्स

वेक्टर के विपरीत, एक लिस्ट में विभिन्न डेटा प्रकारों के तत्व हो सकते हैं और इसे अक्सर मानों का क्रमबद्ध संग्रह कहा जाता है। इसमें वेक्टर, फ़ंक्शंस, मैट्रिक्स, और यहाँ तक कि दूसरी लिस्ट (nested-list) भी हो सकती है।

R में लिस्ट्स one-indexed होती हैं, यानी इंडेक्सिंग एक से शुरू होती है।

एक त्वरित उदाहरण से लिस्ट की अवधारणा समझते हैं, जिसमें एक ही लिस्ट में तीन अलग-अलग डेटा प्रकार होंगे।

lis1 <- 1:5  # Integer Vector
lis1

1. 1
2. 2
3. 3
4. 4
5. 5

lis2 <- factor(1:5)  # Factor Vector
lis2

1. 1
2. 2
3. 3
4. 4
5. 5

lis3 <- letters[1:5]  # Character Vector
lis3

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

combined_list <- list(lis1, lis2, lis3)

combined_list

1. 1. 1
   2. 2
   3. 3
   4. 4
   5. 5
   1. 1
   2. 2
   3. 3
   4. 4
   5. 5
2. Levels:

   1. '1'
   2. '2'
   3. '3'
   4. '4'
   5. '5'
   1. 'a'
   2. 'b'
   3. 'c'
   4. 'd'
   5. 'e'

आइए लिस्ट में मौजूद प्रत्येक वेक्टर को अलग-अलग एक्सेस करें। ऐसा करने के लिए, आप double square brackets का उपयोग करेंगे क्योंकि तीनों वेक्टर लिस्ट के अंदर एक ही स्तर पर हैं। python combined_list[[1]]

1. 1
2. 2
3. 3
4. 4
5. 5

python combined_list[[2]]

1. 1
2. 2
3. 3
4. 4
5. 5

combined_list[[3]]

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

अब, तीसरे वेक्टर के पाँचवें तत्व को एक्सेस करने की कोशिश करते हैं, जो अक्षर e देता है।

combined_list[[3]][5]

'e'

अंत में, लिस्ट को flatten करने की कोशिश करते हैं। एक महत्वपूर्ण बात याद रखने की यह है कि चूँकि combined_list character और numeric डेटाटाइप का संयोजन है, इसलिए character डेटा प्रकार को प्राथमिकता मिलेगी और पूरी लिस्ट का डेटा प्रकार character बन जाएगा।

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '1'
7. '2'
8. '3'
9. '4'
10. '5'
11. 'a'
12. 'b'
13. 'c'
14. 'd'
15. 'e'

length(flat_list)

15

वेक्टर

वेक्टर एक ऑब्जेक्ट है जिसका उपयोग एक ही डेटा प्रकार की कई जानकारी या मानों को स्टोर करने के लिए किया जाता है। एक वेक्टर में integer और character दोनों का संयोजन नहीं हो सकता। उदाहरण के लिए, यदि आप 100 छात्रों के कुल अंक स्टोर करना चाहते हैं, तो प्रत्येक छात्र के लिए 100 अलग-अलग वेरिएबल बनाने की बजाय आप लंबाई 100 का एक वेक्टर बनाएँगे, जो सभी छात्रों के अंक रखेगा।

वेक्टर c() फ़ंक्शन से बनाया जा सकता है, जो सभी तत्वों को मिलाकर एक एक-आयामी array लौटाता है।

आइए पाँच छात्रों के डेटा के साथ numeric वर्ग का एक वेक्टर marks बनाते हैं।

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

वेक्टर की लंबाई जाँचते हैं, जो इसमें निहित तत्वों की संख्या लौटाएगी।

length(marks)

5

अब, किसी विशिष्ट इंडेक्स से तत्व एक्सेस करते हैं।

marks[4]

40

marks[5]

65

marks[6] #returns NA since there is no sixth element in the vector

<NA>

• Slicing: Python की तरह, R में भी slicing की अवधारणा लागू की जा सकती है।

  आइए slicing का उपयोग करके दूसरे से पाँचवें तक के तत्व एक्सेस करें।

marks[2:5]

1. 65
2. 90
3. 40
4. 65

अब एक character वेक्टर बनाते हैं, जो numeric वेक्टर की तरह ही बनाया जाता है।

char_vector <- c("a", "b", "c")
print(char_vector)

[1] "a" "b" "c"

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]

1. 'a'
2. 'b'
3. 'c'

यदि हम ऐसा वेक्टर बनाते हैं जिसमें numeric और character दोनों मान हों, तो numeric मान character डेटा प्रकार में बदल जाएँगे।

char_num_vec <- c(1,2, "a")

char_num_vec

1. '1'
2. '2'
3. 'a'

class(char_num_vec)

'character'

स्लाइसिंग की अवधारणा की मदद से 1024 numeric मानों वाला एक वेक्टर बनाते हैं।

vec <- c(1:1024)

अब मध्य और अंतिम तत्व एक्सेस करने की कोशिश करें। इसके लिए आप length फ़ंक्शन का उपयोग करेंगे।

vec[length(vec)]

1024

vec[length(vec)/2]

512

• आप विषम संख्याओं का वेक्टर कैसे बनाते हैं?

विषम संख्याओं का वेक्टर बनाने के लिए, आप seq फ़ंक्शन का उपयोग कर सकते हैं, जो तीन पैरामीटर लेता है: शुरुआत, अंत, और step size।

seq(1,10, by = 2)

1. 1
2. 3
3. 5
4. 7
5. 9

मैट्रिक्स

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

मैट्रिक्स परिभाषित करने का सिंटैक्स:

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE का अर्थ है कि मैट्रिक्स को पंक्तियों के अनुसार भरा जाना चाहिए। byrow=FALSE इंगित करता है कि मैट्रिक्स को स्तंभों के अनुसार भरा जाना चाहिए (डिफ़ॉल्ट)।

आइए जल्दी से आकार $2\times3$ का एक मैट्रिक्स M परिभाषित करें।

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

स्लाइसिंग की अवधारणा का उपयोग करते हैं और पंक्ति तथा स्तंभ से तत्व निकालते हैं।

M[1:2,1:2] #the first dimension selects both rows while the second dimension will select
#elements from 1st and 2nd column

डेटाफ्रेम

मैट्रिक्स के विपरीत, डेटा फ्रेम एक अधिक सामान्यीकृत रूप है। इसमें डेटा सारणीबद्ध रूप में होता है। डेटा फ्रेम में डेटा विभिन्न स्तंभों में फैला हो सकता है, जिनके डेटा प्रकार अलग-अलग हो सकते हैं। पहला स्तंभ character, दूसरा integer और तीसरा logical हो सकता है।

वेरिएबल्स या फ़ीचर्स स्तंभों में होते हैं, जिन्हें header भी कहा जाता है, जबकि प्रेक्षण (observations) पंक्तियों में होते हैं, जहाँ पहला तत्व पंक्ति का नाम होता है और उसके बाद वास्तविक डेटा, जिसे data rows कहा जाता है।

डेटाफ्रेम data.frame() फ़ंक्शन का उपयोग करके बनाया जा सकता है।

डेटाफ्रेम का व्यापक उपयोग कॉमा-सेपरेटेड फाइल्स (CSV), टेक्स्ट फाइल्स पढ़ने में होता है। इनका उपयोग केवल डेटा पढ़ने तक सीमित नहीं है; आप इन्हें मशीन लर्निंग समस्याओं में भी उपयोग कर सकते हैं, खासकर जब आप संख्यात्मक डेटा से निपट रहे हों। डेटा समझने, डेटा रैंगलिंग, plotting और visualization के लिए डेटा फ्रेम उपयोगी होते हैं।

एक डमी डेटासेट बनाते हैं और कुछ डेटा फ्रेम-विशिष्ट फ़ंक्शंस सीखते हैं।

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # this will give you the number of rows that are there in the dataset dataframe

3

ncol(dataset) # this will give you the number of columns that are there in the dataset dataframe

5

df1 = rbind(dataset, dataset) # a row bind which will append the arguments in row fashion.

df1

df2 = cbind(dataset, dataset) # a column bind which will append the arguments in column fashion.

df2

आइए head फ़ंक्शन देखते हैं जो तब बहुत उपयोगी होता है जब आपके पास लाखों रिकॉर्ड हों और आप केवल शुरुआती कुछ पंक्तियाँ देखना चाहते हों। इसी तरह, tail फ़ंक्शन आपके डेटा की अंतिम कुछ पंक्तियाँ आउटपुट करेगा।

head(df1,3) # here only three rows will be printed

str(dataset) #this returns the individual class or data type information for each column.

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

अब summary() फ़ंक्शन देखते हैं, जो तब उपयोगी होता है जब आप अपने डेटासेट के सांख्यिकीय पहलुओं को समझना चाहते हों। जैसा कि नीचे दिखाया गया है, यह आपके डेटा को तीन क्वार्टाइल में बाँटता है, जिसके आधार पर आप डेटा के वितरण के बारे में कुछ सहज समझ बना सकते हैं। यह यह भी दिखाता है कि आपके डेटासेट में कोई missing values हैं या नहीं।

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000  

निष्कर्ष

ट्यूटोरियल पूरा करने पर बधाई।

यह ट्यूटोरियल R प्रोग्रामिंग भाषा सीखने के इच्छुक शुरुआती लोगों के लिए एक अच्छा शुरुआती बिंदु था। एक अच्छे अभ्यास के रूप में, निःसंकोच प्रत्येक डेटा प्रकार से संबंधित और सहायक फ़ंक्शंस देखें।

R से संबंधित बहुत-सी जानकारियाँ अभी शेष हैं जैसे R में कंटिडिशनल्स और कंट्रोल फ्लो, R में यूटिलिटीज, और सबसे रोचक—R का उपयोग करके मशीन लर्निंग—जिन्हें भविष्य के ट्यूटोरियल्स में कवर किया जाएगा, तो जुड़े रहें!

कृपया इस ट्यूटोरियल से संबंधित कोई भी प्रश्न नीचे कमेंट सेक्शन में पूछें।

यदि आप R के बारे में और सीखना चाहते हैं, तो DataCamp का Intermediate R कोर्स लें और Introduction to Data frames in R ट्यूटोरियल देखें।