R में यूटिलिटीज़ ट्यूटोरियल

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

गणितीय फ़ंक्शंस

आइए कुछ कोड सेल्स देखें जो कई गणितीय फ़ंक्शंस का उपयोग करते हैं।

आप सबसे पहले दो वेक्टर परिभाषित करेंगे, यानी x और y, जिनमें धनात्मक और ऋणात्मक दोनों मान होंगे।

x <- c(1.1, -2.3, -4.5)
y <- c(2.4,-44, -2.2)
संचालित द्वारा

print(x)
संचालित द्वारा

[1]  1.1 -2.3 -4.5संचालित द्वारा

print(y)
संचालित द्वारा

[1]   2.4 -44.0  -2.2संचालित द्वारा

अब इन दोनों वेक्टर x और y को लें:

• इनके परिमाण मान (absolute values) लें,
• उन्हें शून्य दशमलव स्थान तक राउंड करें,
• प्रत्येक का योग लें और
• अंत में, दोनों का औसत लें।

mean(c(sum(round(abs(x))),sum(round(abs(y)))))
संचालित द्वारा

27.5संचालित द्वारा

क्यों न आप ऊपर की कोड लाइन को छोटे हिस्सों में तोड़कर प्रत्येक फ़ंक्शन को बारीकी से देखें।

• abs() फ़ंक्शन बस वेक्टर x और y के तत्वों के धनात्मक या परिमाण मान पर विचार करता है।

उदाहरण के लिए, x और y पर abs() लागू करने पर आप सभी धनात्मक मानों की अपेक्षा करेंगे, जैसा नीचे दिखाया गया है।

abs(x)
संचालित द्वारा

1. 1.1
2. 2.3
3. 4.5

abs(y)
संचालित द्वारा

1. 2.4
2. 44
3. 2.2

• अगला फ़ंक्शन round() है। यह इनपुट को राउंड करता है। यह एक अतिरिक्त आर्ग्युमेंट लेता है, जिसमें आप निर्दिष्ट कर सकते हैं कि कितने दशमलव स्थान तक राउंड करना है। सामान्यतः, round() इनपुट को शून्य दशमलव स्थान तक राउंड करता है।

उदाहरण के लिए, जब आप x और y वेक्टर पर round() लागू करते हैं, तो आउटपुट नीचे जैसा होगा:

round(x)
संचालित द्वारा

1. 1
2. -2
3. -4

round(y)
संचालित द्वारा

1. 2
2. -44
3. -2

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

इस मामले में, वेक्टर x और y को sum() में पास किया गया है। इसलिए, R साधारणतः तत्वों का योग निकालता है और आउटपुट में एक स्केलर देता है।

sum(abs(round(x)))
संचालित द्वारा

7संचालित द्वारा

sum(abs(round(y)))
संचालित द्वारा

 48संचालित द्वारा

• अंत में, mean() या average() फ़ंक्शन अंकगणितीय माध्य निकालता है। यह संख्यात्मक मानों के सेट का औसत लेता है: उन्हें जोड़ता है और सेट में पदों की संख्या से भाग देता है।

यहाँ, mean() का इनपुट लंबाई दो का रो-वेक्टर है जिसमें संख्याएँ 7 और 48 हैं। तो इनका औसत इनका योग विभाजित तत्वों की संख्या, यानी 2, होगा।

mean(c(7,48))
संचालित द्वारा

27.5संचालित द्वारा

यह तो काफ़ी आसान था, है ना?

अब इस ट्यूटोरियल के अगले और सबसे दिलचस्प हिस्से पर चलते हैं!

डेटा संरचनाओं के लिए फ़ंक्शंस

अब सूची (list) और वेक्टर जैसी कुछ डेटा संरचनाएँ देखें। आप list डेटा संरचना पर अलग-अलग तरीकों से काम करना, किसी list को उलटना (reversing), और किसी सूची को वेक्टर में तथा वेक्टर को सूची में बदलना सीखेंगे।

नीचे दिया फ़ंक्शन एक list() है, या आप इसे list of lists भी कह सकते हैं, जिसे nested-list भी कहा जाता है। यह ऐसे तत्वों की सूची बनाता है जिनमें logical मान, संख्यात्मक मान और स्ट्रिंग्स हो सकती हैं।

नीचे के उदाहरण में, एक सूची के भीतर तीन सूचियाँ हैं, अर्थात् log, ch, और int_vec। इनमें क्रमशः logical, numeric, और string/character प्रकार के R ऑब्जेक्ट हैं।

list_define <- list(log = TRUE, ch = "hello_datacamp", int_vec = sort(rep(seq(8,2, by = -2), times = 2)))
संचालित द्वारा

list_define
संचालित द्वारा

$log

TRUE

$ch

'hello_datacamp'

$int_vec

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

• log एक सरल logical ऑपरेटर है, TRUE या FALSE
• ch एक कैरेक्टर स्ट्रिंग hello_datacamp है
• int_vec संख्यात्मक मानों का एक अनुक्रम है।

क्योंकि log और ch सीधे-सरल हैं, आइए int_vec को थोड़ा और नज़दीक से देखें।

int_vec = sort(rep(seq(8,2, by = -2), times = 2))
संचालित द्वारा

int_vec
संचालित द्वारा

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

ऊपर के एक्सप्रेशन को चरण-दर-चरण समझते हैं।

seq फ़ंक्शन 8 से 2 तक अवरोही क्रम में संख्याओं का अनुक्रम बनाता है।

seq() फ़ंक्शन का सिन्टैक्स है: seq(x1,x2, by = y)

पहले दो आर्ग्युमेंट x1 और x2 R को अनुक्रम की रेंज बताते हैं, यानी अनुक्रम कहाँ से शुरू और कहाँ समाप्त होगा। by आर्ग्युमेंट प्रत्येक अंतराल पर अनुक्रम में वृद्धि या कमी की मात्रा बताता है।

उदाहरण के लिए, नीचे की कोड लाइन 100 से 200 तक 20 के इन्क्रीमेंट स्टेप के साथ एक अनुक्रम बनाएगी।

seq(100,200, by = 20)
संचालित द्वारा

1. 100
2. 120
3. 140
4. 160
5. 180
6. 200

हमारे उदाहरण में, sequence फ़ंक्शन 8 से 2 (समावेशी) तक 2 की कमी के स्टेप के साथ एक अनुक्रम देगा, जो लंबाई 4 का वेक्टर लौटाता है।

a = seq(8,2, by = -2)
संचालित द्वारा

a
संचालित द्वारा

1. 8
2. 6
3. 4
4. 2

अब rep फ़ंक्शन को समझते हैं।

यह इनपुट आर्ग्युमेंट (आमतौर पर वेक्टर या सूची) को times का उपयोग कर दोहराता है, जहाँ times एक पूर्णांक है और इनपुट या अनुक्रम को उतनी बार दोहराता है। rep दो आर्ग्युमेंट लेता है: इनपुट और आप इनपुट को कितनी बार दोहराना/प्रतिलिपि बनाना चाहते हैं।

हमारे उदाहरण में लंबाई 4 के वेक्टर पर rep लगाने से लंबाई 8 का आउटपुट वेक्टर मिलता है।

b = rep(a, times = 2)
संचालित द्वारा

यदि आप पूरे वेक्टर के बजाय वेक्टर/सूची के प्रत्येक तत्व को दोहराना चाहते हैं, तो times का विकल्प है each आर्ग्युमेंट।

times और each का उपयोग करने में स्पष्ट अंतर यह है कि तत्वों के आने का पैटर्न समान नहीं रहता।

rep(a, each = 2)
संचालित द्वारा

1. 8
2. 8
3. 6
4. 6
5. 4
6. 4
7. 2
8. 2

अंत में, sort() फ़ंक्शन। यह स्वयं स्पष्ट और एक सामान्य फ़ंक्शन है जो वेक्टर या सूची जैसी कई डेटा संरचनाओं को सॉर्ट करने के लिए उपयोग होता है। यह केवल संख्यात्मक मानों तक सीमित नहीं है, बल्कि logical मानों और कैरेक्टर्स पर भी लागू हो सकता है। डिफ़ॉल्ट रूप से, यह तत्वों को आरोही क्रम में सॉर्ट करता है।

अंतिम आउटपुट पाने के लिए rep फ़ंक्शन के आउटपुट को sort में दें।

sort(b)
संचालित द्वारा

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

बहुत बढ़िया! आपने सूची list_define के अंदर वाले लंबे एक्सप्रेशन int_vec को इतने आसान तरीके से हल कर लिया।

आगे, सूची list_define की सामग्री जानें, जिसके लिए आप str() फ़ंक्शन का उपयोग करेंगे। R में str() फ़ंक्शन R ऑब्जेक्ट्स की संरचना प्रदर्शित करने देता है।

str(list_define)
संचालित द्वारा

List of 3
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8संचालित द्वारा

आइए कुछ रोचक R एक्सप्रेशंस देखें:

• is फ़ंक्शन का उपयोग आपकी डेटा संरचना के प्रकार की जाँच के लिए किया जा सकता है, जो एक logical मान लौटाता है और कंडीशनल स्टेटमेंट्स में काम आता है।

is.list(list_define) #आर्ग्युमेंट सूची है तो true लौटाता है।
संचालित द्वारा

TRUEसंचालित द्वारा

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

is.list(c(1,2,3)) #false लौटता है क्योंकि आपने वेक्टर पास किया।
संचालित द्वारा

FALSEसंचालित द्वारा

• R में वेक्टर को सूची में बदलना बहुत सरल है। बस as फ़ंक्शन के बाद .list() का उपयोग करें, और वेक्टर को आर्ग्युमेंट के रूप में पास करें। इतना ही करना होता है।

vec_to_list <- as.list(c(1,2,3))
संचालित द्वारा

is.list(vec_to_list) #is.list() से सत्यापित करें
संचालित द्वारा

TRUEसंचालित द्वारा

• दूसरी ओर, unlist फ़ंक्शन का उपयोग कर किसी सूची को वेक्टर में बदला जा सकता है। R यह रूपांतरण पूरी सूची संरचना को flatten करके करता है और अंततः एक सिंगल वेक्टर देता है।

list_to_vec <- unlist(vec_to_list)
संचालित द्वारा

list_to_vec
संचालित द्वारा

1. 1
2. 2
3. 3

is.list() की तरह, आप is.vector() का उपयोग यह जाँचने के लिए कर सकते हैं कि आर्ग्युमेंट वेक्टर है या नहीं।

is.vector(list_to_vec)
संचालित द्वारा

TRUEसंचालित द्वारा

आइए बड़ी सूची list_define को वेक्टर में बदलें। ध्यान देने योग्य बात यह है कि एक वेक्टर में केवल एक ही डेटा प्रकार या R ऑब्जेक्ट हो सकता है। इसलिए, logical और numerical दोनों मान स्ट्रिंग्स में बदल दिए जाएंगे।

unlist(list_define)
संचालित द्वारा

log

'TRUE'

ch

'hello_datacamp'

int_vec1

'2'

int_vec2

'2'

int_vec3

'4'

int_vec4

'4'

int_vec5

'6'

int_vec6

'6'

int_vec7

'8'

int_vec8

'8'

अगले विषय पर जाने से पहले, append() और rev() फ़ंक्शंस देखें।

• जैसा नाम से स्पष्ट है, append() फ़ंक्शन आपको मौजूदा या नई वेक्टर/सूची में दो या अधिक वेक्टर या सूचियाँ जोड़ने की अनुमति देता है।

list_define सूची पर append() आज़माएँ। आप देखेंगे कि अब सूची में 3 के बजाय 6 तत्व होंगे क्योंकि आपने उसी सूची को स्वयं से जोड़ दिया।

str(append(list_define, list_define))
संचालित द्वारा

List of 6
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8संचालित द्वारा

• अंत में, R में rev() फ़ंक्शन की मदद से list_define सूची का क्रम उलट दें।

str(rev(list_define))
संचालित द्वारा

List of 3
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ ch     : chr "hello_datacamp"
 $ log    : logi TRUEसंचालित द्वारा

रेगुलर एक्सप्रेशंस

कई लोगों को रेगुलर एक्सप्रेशन सीखना जटिल लगता है। हालाँकि, यह न केवल R बल्कि Python जैसी विभिन्न प्रोग्रामिंग भाषाओं में एक आवश्यक विषय है। कई भाषाएँ, R सहित, बिल्ट-इन रेगुलर एक्सप्रेशन क्षमता प्रदान करती हैं।

रेगुलर एक्सप्रेशन का उपयोग कई अनुप्रयोगों में किया जा सकता है, और यह विशेषकर तब उपयोगी होता है जब आप टेक्स्ट डेटा का प्रीप्रोसेसिंग करना चाहते हैं। यह विभिन्न Natural Language Processing (NLP) समस्याओं में उपयोग होता है।

यह क्वेरी सर्च इंजन और टेक्स्ट एडिटर्स में भी उपयोग किया जाता है।

रेगुलर एक्सप्रेशंस, जिन्हें regex या regexp या rational operators भी कहा जाता है, ऐसे कैरेक्टर्स का क्रम है जो एक सर्च पैटर्न को परिभाषित करता है। आमतौर पर, ये पैटर्न विभिन्न स्ट्रिंग सर्चिंग एल्गोरिद्म्स द्वारा पैटर्न खोजने, खोजकर बदलने या मिलान किए पैटर्न को फ़िल्टर करने के लिए उपयोग किए जाते हैं।

आइए grep() और grepl() फ़ंक्शंस के उपयोग को समझकर शुरू करें।

सरलता के लिए, लंबाई 5 का एक रो-वेक्टर animals_regex परिभाषित करें, जिस पर आप regex पैटर्न लगाना सीखेंगे।

animals_regex <- c('cat','dog','cheetah','lion','mice')
संचालित द्वारा

पहले, grepl() फ़ंक्शन समझें। grepl() एक logical आउटपुट देता है, यानी यदि स्ट्रिंग पैटर्न से मेल खाती है तो TRUE लौटाता है, अन्यथा FALSE।

नीचे grepl() का सरल और सहज सिंटैक्स है जहाँ पहला आर्ग्युमेंट वह पैटर्न है जिसे आप मिलाना चाहते हैं और दूसरा आर्ग्युमेंट वह स्ट्रिंग/इनपुट है जिसमें आप पैटर्न खोजना या फ़िल्टर करना चाहते हैं। शेष आर्ग्युमेंट्स को अभी के लिए नज़रअंदाज़ कर सकते हैं। grepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) आइए ऊपर दिए पाँच जानवरों में से किन-किन में c है, यह grepl() की मदद से निकालें।

इस मामले में, आप उन जानवरों को ढूँढ रहे हैं जिनमें c है, यानी पैटर्न यहाँ c ही है।

grepl(pattern = 'c', x = animals_regex)
संचालित द्वारा

1. TRUE
2. FALSE
3. TRUE
4. FALSE
5. TRUE

ऊपर के आउटपुट से आप देख सकते हैं कि cat, cheetah और mice में c होने के कारण उन इंडेक्स पर TRUE लौटा, जबकि जहाँ पैटर्न c नहीं था वहाँ FALSE लौटा।

आइए वे तत्व ढूँढें जो c से शुरू होते हैं, न कि सिर्फ़ जिनके नाम में c आता है।

इसके लिए आपको बस पैटर्न की शुरुआत में ^ (caret) चिह्न लगाना होगा।

grepl(pattern = '^c', x = animals_regex) #केवल cat और cheetah `c` से शुरू होते हैं।
संचालित द्वारा

1. TRUE
2. FALSE
3. TRUE
4. FALSE
5. FALSE

तो ऊपर के आउटपुट से दिखता है कि केवल cat और cheetah c से शुरू होते हैं, इसलिए केवल वही पोज़िशन TRUE हैं।

^ चिन्ह की तरह, $ चिन्ह पैटर्न के अंत में लगाया जा सकता है ताकि निर्दिष्ट पैटर्न पर समाप्त होने वाले तत्व मिल सकें। ऐसा जानवर ढूँढने के लिए जो n पर समाप्त होता है, आप n के बाद $ लगा सकते हैं।

grepl(pattern = 'n$', x = animals_regex) #केवल lion `n` पर समाप्त होता है।
संचालित द्वारा

1. FALSE
2. FALSE
3. FALSE
4. TRUE
5. FALSE

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

• grepl() की तरह, grep() फ़ंक्शन होता है, जो logical आउटपुट के बजाय दिए गए पैटर्न से मेल खाने वाले वेक्टर/मैट्रिक्स के इंडेक्स लौटाता है।

grep() फ़ंक्शन का सिंटैक्स grepl() जैसा ही है: grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE, invert = FALSE) आइए ऊपर वाले उदाहरण को ही लें लेकिन इस बार grep() लगाएँ!

grep(pattern = 'c', x = animals_regex)
संचालित द्वारा

1. 1
2. 3
3. 5

जैसा आप अपेक्षा करेंगे, ऊपर का आउटपुट cat, cheetah और mice के इंडेक्स लौटाता है, न कि TRUE/FALSE। और बस, इतना ही!

आइए which फ़ंक्शन का उपयोग करके grep() और grepl() की तुलना करें। which() फ़ंक्शन किसी logical ऑब्जेक्ट में TRUE इंडेक्स के स्थान लौटाता है।

अब यदि आप जोड़ें, तो समझ आएगा कि क्योंकि grepl() logical ऑब्जेक्ट लौटा सकता है, इसे which() को पास करने पर आउटपुट वैसा ही हो जाएगा जैसा आप grep() से अपेक्षा करते हैं।

which(grepl(pattern = 'c', x = animals_regex))
संचालित द्वारा

1. 1
2. 3
3. 5

grepl() की तरह, grep() भी विभिन्न प्रकार के रेगुलर एक्सप्रेशन पैटर्न संभालना जानता है।

यदि आप grep() का उपयोग animals_regex वेक्टर के उन तत्वों को ढूँढने के लिए करें जो n पर समाप्त होते हैं, तो आउटपुट 4 आएगा क्योंकि केवल lion n पर समाप्त होता है, जैसा नीचे दिखाया गया है।

grep(pattern = 'n$', x = animals_regex)
संचालित द्वारा

4संचालित द्वारा

शाबाश!

आपने रेगुलर एक्सप्रेशंस की कुछ बुनियादी बातें सीख लीं, जैसे किसी वेक्टर से दिए गए पैटर्न से मेल खाने वाले तत्वों को फ़िल्टर करना। हालाँकि, R केवल पैटर्न मिलान तक सीमित नहीं है। इसके पास कई फ़ंक्शंस हैं, जिनमें से sub() एक है।

sub() फ़ंक्शन मिलान किए पैटर्न को फ़िल्टर करने के बजाय, उन्हें अन्य स्ट्रिंग्स से बदल देता है। इसे थोड़ा गहराई से समझते हैं!

• sub() फ़ंक्शन मुख्यतः तीन इनपुट आर्ग्युमेंट लेता है:
  • pattern जिसे आप मिलाना चाहते हैं या रेगुलर एक्सप्रेशन,
  • replacement मान जो वेक्टर के मिलान किए तत्व पर रखा जाएगा, और
  • x वह इनपुट वेक्टर स्ट्रिंग जिस पर आप regex लगाएंगे।

सिन्टैक्स है: sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,fixed = FALSE, useBytes = FALSE) इस बार भी ऊपर वाला ही उदाहरण लें ताकि इसकी कार्यप्रणाली समझ आए!

sub(pattern = 'c', replacement = 'a', x = animals_regex)
संचालित द्वारा

1. 'aat'
2. 'dog'
3. 'aheetah'
4. 'lion'
5. 'miae'

ऊपर के आउटपुट से आप देख सकते हैं कि cat स्ट्रिंग aat बन गई, cheetah aheetah बन गया, और mice miae में बदल गया। इन तत्वों के लिए पैटर्न सफलतापूर्वक मिला।

ध्यान दें कि sub() स्ट्रिंग में केवल पहले मिलान को देखता है, यानी यदि किसी स्ट्रिंग में दो c हैं, तो केवल पहले c को a से बदला जाएगा जबकि दूसरा अपरिवर्तित रहेगा।

यदि आप किसी स्ट्रिंग में पैटर्न के हर एक मिलान को बदलना चाहते हैं, तो gsub() का उपयोग करें, जो इस ट्यूटोरियल के दायरे से बाहर है!

अगले विषय पर जाने से पहले, एक और दिलचस्प एक्सप्रेशन आज़माते हैं।

इस बार आप | (OR) ऑपरेटर का उपयोग करेंगे जो परिभाषित पैटर्न में से किसी से भी मेल कराने की कोशिश करेगा और यदि मेल हुआ, तो उसे - से बदल देगा। याद रखें, चूँकि आप gsub() फ़ंक्शन का उपयोग कर रहे हैं, यह स्ट्रिंग में पैटर्न के हर मिलान को बदलेगा।

gsub(pattern = 'c|d|l', replacement = '-', x = animals_regex) #जिन जानवरों में `c`,`d`,`l` हैं वे `-` से बदल दिए जाएँगे।
संचालित द्वारा

1. '-at'
2. '-og'
3. '-heetah'
4. '-ion'
5. 'mi-e'

अब आज के अंतिम विषय पर चलते हैं, यानी समय और तारीखें!

समय और तारीखें

समय और तारीख की जानकारी कई परिदृश्यों में उपयोगी हो सकती है। उदाहरण के लिए, मान लें आप किसी Computer Vision से संबंधित समस्या पर काम कर रहे हैं और जानना चाहते हैं कि आपका एल्गोरिद्म किस FPS (frames per second) पर चल रहा है। ऐसे उपयोग-मामले में, आप Time ऑब्जेक्ट का उपयोग अपने कंप्यूटर विज़न एल्गोरिद्म की प्रोसेसिंग स्पीड जानने के लिए कर सकते हैं। अन्य विशिष्ट समस्याओं जैसे टाइम-सीरीज़ फ़ोरकास्टिंग और सीज़नैलिटी स्टडीज़ के लिए, R की क्षमता का पूरा उपयोग किया जा सकता है।

शुरुआत के लिए, R में एक सरल कमांड Sys.Date() से आज की तारीख़ प्रिंट करते हैं। यहाँ Sys का अर्थ system से है, यानी यह सिस्टम द्वारा मानी गई तारीख़ लौटाता है।

Sys.Date()
संचालित द्वारा

2020-02-04

सीधा-सादा है, है ना?

R का समय और तारीख़ Date ऑब्जेक्ट से संबंधित है, या कहें डेटा टाइप Date है। इसे आप Data Types in R ट्यूटोरियल में सीखे गए class फ़ंक्शन से जाँच सकते हैं।

Date फ़ंक्शन की तरह, आपके पास time() फ़ंक्शन भी है जो सिस्टम का वर्तमान समय लौटाता है; दरअसल यह समय और तारीख़ दोनों देता है।

Sys.time()
संचालित द्वारा

[1] "2020-02-04 02:05:04 IST"संचालित द्वारा

Date ऑब्जेक्ट बनाना

आपने वर्तमान तारीख़ और समय प्राप्त करना सीख लिया। अब जानें कि केवल एक स्ट्रिंग पास करके अन्य दिनों की तारीख़ें कैसे बनाई जा सकती हैं।

10 मई 1993 के लिए एक तारीख़ ऑब्जेक्ट बनाने हेतु आप निम्नलिखित सिंटैक्स का उपयोग करेंगे:

date_may <- as.Date('1993-05-10') #कैरेक्टर स्ट्रिंग को date ऑब्जेक्ट में बदलता है
संचालित द्वारा

date_may
संचालित द्वारा

1993-05-10

class(date_may)
संचालित द्वारा

'Date'संचालित द्वारा

एक महत्वपूर्ण बात: R का Date फ़ंक्शन डिफ़ॉल्ट रूप से आपसे YYYY-MM-DD फ़ॉर्मेट में तारीख़ की अपेक्षा करता है। यदि आप वर्ष, माह या दिन को आपस में बदलते हैं, तो त्रुटि होगी। चलिए आज़माते हैं!

date_may <- as.Date('05-1993-10') #R डिफ़ॉल्ट रूप से ISO तारीख़ फ़ॉर्मेट का पालन करता है
संचालित द्वारा

Error in charToDate(x): character string is not in a standard unambiguous format
Traceback:


1. as.Date("05-1993-10")

2. as.Date.character("05-1993-10")

3. charToDate(x)

4. stop("character string is not in a standard unambiguous format")संचालित द्वारा

लेकिन अच्छी बात यह है कि आप format आर्ग्युमेंट पास करके फ़ॉर्मेट को स्पष्ट रूप से बदल सकते हैं और मनचाहा बना सकते हैं।

date_may <- as.Date('05-1993-10', format = '%m-%Y-%d')
संचालित द्वारा

as.Date() अलग-अलग तारीख़ फ़ॉर्मेट स्वीकार करेगा, लेकिन अंत में इसे ISO तारीख़ फ़ॉर्मेट में बदल देगा, जैसा आप date_may प्रिंट करके देख सकते हैं।

date_may
संचालित द्वारा

1993-05-10

date_may <- as.Date('05-10-1993', format = '%m-%d-%Y')
संचालित द्वारा

date_may
संचालित द्वारा

1993-05-10

Date गणित

क्या यह शानदार नहीं होगा यदि आप R में Date ऑब्जेक्ट्स पर जोड़-घटाव जैसे गणितीय ऑपरेशन लागू कर सकें?

आइए date_may में 1 जोड़ें, आप देखेंगे कि यह एक दिन बाद की तारीख़ दिखाएगा।

date_may + 1
संचालित द्वारा

1993-05-11

बहुत बढ़िया, ऊपर के आउटपुट से दिखता है कि 1 जोड़ने से 10 मई 1993 से बदलकर 11 मई 1993 हो गया। इसी तरह, आप तारीख़ से 1 घटा सकते हैं।

मान लें आप अपने और अपने बड़े भाई-बहन की जन्मतिथि के बीच का समय अंतर जानना चाहते हैं।

elder_sib <- as.Date('1989-03-21')
संचालित द्वारा

date_may - elder_sib
संचालित द्वारा

Time difference of 1511 daysसंचालित द्वारा

निष्कर्ष

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

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

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

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