R में स्ट्रिंग्स ट्यूटोरियल

स्ट्रिंग वह अक्षर-माला है जो एक अक्षर से बनी हो सकती है या अक्षरों का समूह हो सकती है। इसे एकल उद्धरण ('This is a string') या द्वि-उद्धरण ("This is also a string") में रखा जाता है। लेकिन आंतरिक अभ्यावेदन में R की स्ट्रिंग्स हमेशा डबल कोट्स में रखी जाती हैं।

इस ट्यूटोरियल में, आप R में स्ट्रिंग्स के बारे में सीखेंगे, और हम निम्नलिखित विषयों को कवर करेंगे।

1. पहले, आप R में स्ट्रिंग्स और R में स्ट्रिंग के नियम देखेंगे।
2. इसके बाद, आप R में स्ट्रिंग के संयोजन (Concatenation) और स्ट्रिंग की अन्य आवश्यक विशेषताओं में गहराई से जाएँगे।
3. साथ ही, किसी कैरेक्टर स्ट्रिंग का निष्कर्षण (Extracting) और प्रतिस्थापन (Replacing) विस्तार से समझाया गया है।
4. अंत में, स्ट्रिंग का फ़ॉर्मेटिंग, जहाँ किसी भी वेक्टर इनपुट को सुव्यवस्थित रूप में बदला जा सकता है।

R में स्ट्रिंग के नियम

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

उदाहरण: 'cars', 'merry"s' , 'merry\'s' R में मान्य स्ट्रिंग्स हैं।

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

उदाहरण: "cars" , "merry's", "merry\"s" भी R में मान्य स्ट्रिंग्स हैं।

स्ट्रिंग का संयोजन (Concatenation)

स्ट्रिंग का संयोजन का अर्थ है स्ट्रिंग्स को जोड़ना या मिलाना।

R में स्ट्रिंग्स को जोड़ने का सिंटैक्स इस प्रकार है:
paste(..., sep = "",collapse = NULL)
paste0(..., collapse = NULL)

ऊपर paste में दिए गए आर्ग्युमेंट का मतलब:

1. '...'- एक या अधिक अक्षर या ऑब्जेक्ट्स जो कैरेक्टर वेक्टर में बदले जाते हैं।
2. 'sep'- अलगाव (सेपरेटर) का कैरेक्टर दर्शाता है
3. 'collapse'- वैकल्पिक अलगाव कैरेक्टर दर्शाता है।

उदाहरण के लिए, नीचे दिए उदाहरण में वेरिएबल्स में कैरेक्टर स्ट्रिंग्स हैं: my.var1 = "I" my.var2 = "eat" my.var3 = "rice" print(paste(my.var1,my.var2,my.var3))

उपरोक्त कोड एक एकल स्ट्रिंग देता है जैसा कि नीचे है:

"I eat rice"संचालित द्वारा

उदाहरण के लिए, नीचे दिया उदाहरण देखें जहाँ वेरिएबल्स में वेक्टर हैं जिन्हें एक स्ट्रिंग में बदला जाता है:

my.var1 = c('Book','Copy') my.var2 = c('Pen','Chair') print(paste(my.var1,my.var2,sep=" ",collapse="-"))

ऊपर के कोड का आउटपुट इस प्रकार है:

"Book Pen-Copy Chair"संचालित द्वारा

यहाँ, आउटपुट में Pen और Copy के बीच '-' आता है क्योंकि collapse का उपयोग किया गया है, जो दो अलग-अलग वेक्टरों के बीच अलगाव बनाता है। इसके विपरीत, sep में एक स्पेस (' ') शामिल है, जिससे व्यक्तिगत आइटम उसके द्वारा अलग किए जाते हैं।

आइए paste0() वाला उदाहरण देखें

paste0() sep = '' अर्थात बिना स्पेस के आर्ग्युमेंट लेता है और दक्षता के लिए उपयोग होता है।

state.name <- paste0('Mary','l','and')
print(state.name)संचालित द्वारा

ऊपर दिए कोड का आउटपुट नीचे है जहाँ सभी अक्षर मिलकर एक हो जाते हैं, और sep के माध्यम से कोई अलग स्पेस नहीं है।

"Maryland"
संचालित द्वारा

लंबाई निकालना

nchar(char,type, allowNA,keepNA) - दिए गए वेक्टर में कुल अक्षरों की संख्या निकालना।
nzchar(char)- यदि x खाली नहीं है तो TRUE और यदि वह कोई खाली स्ट्रिंग है तो FALSE लौटाता है।

ऊपर paste में दिए गए आर्ग्युमेंट्स का अर्थ:

1. char- एक कैरेक्टर वेक्टर दर्शाता है।
2. type- तीन में से एक प्रकार दर्शाता है, जैसे "width","chars","bytes"।
3. allowNA- लॉजिकल, डिफ़ॉल्ट FALSE। यदि परिणाम निकाला नहीं जा सके तो त्रुटि नहीं देगा बल्कि NA लौटाएगा।
4. keepNA- लॉजिकल, डिफ़ॉल्ट FALSE, जहाँ missing value को 2 पर मैप करेगा और nzchar() TRUE देगा, लेकिन missing values के मामले में दोनों TRUE पर मैप करेंगे।

नीचे दिए उदाहरण में किसी कैरेक्टर वेक्टर की लंबाई जानने के लिए: my.char = nchar("hello") print(my.char)


उपरोक्त उदाहरण '5' लौटाता है, क्योंकि वेक्टर में पाँच अक्षर मौजूद हैं।

nzchar() के उपयोग के उदाहरण के लिए नीचे का कोड देखें:

new.char = nzchar("monkey") print(new.char)

ऊपर का कोड लॉजिकल मान 'TRUE' देता है क्योंकि 'new.char' खाली स्ट्रिंग नहीं है।

my.char = nzchar("") print(my.char)

ऊपर का कोड लॉजिकल मान 'FALSE' देता है क्योंकि 'my.char' एक खाली स्ट्रिंग है।

अपर केस और लोअर केस में बदलना

toupper(char) - सभी अक्षरों को अपरकेस में बदलता है।
tolower(char) - सभी अक्षरों को लोअरकेस में बदलता है।

अपरकेस में बदलने का उदाहरण देखें। my.var = toupper("I'm changed to upper case") print(my.var)

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ वेरिएबल 'my.var' में मौजूद प्रत्येक अक्षर अपरकेस में बदल गया है।

"I'M CHANGED TO UPPER CASE"संचालित द्वारा

लोअरकेस में बदलने का उदाहरण देखें। my.var = tolower("I'm changed to lower case") print(my.var)

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ वेरिएबल 'my.var' में मौजूद प्रत्येक अक्षर लोअरकेस में बदल गया है।

""i'm changed to lower case""संचालित द्वारा

किसी कैरेक्टर स्ट्रिंग का निष्कर्षण और प्रतिस्थापन

substr(char, start, stop): किसी कैरेक्टर स्ट्रिंग का निष्कर्षण और प्रतिस्थापन।

ऊपर दिए आर्ग्युमेंट्स का अर्थ:

1. char- एक कैरेक्टर स्ट्रिंग दर्शाता है।
2. start - ऐसा पूर्णांक जो लौटाए जाने वाले प्रारंभिक मान को निर्दिष्ट करता है।
3. stop - ऐसा पूर्णांक जो लौटाए जाने वाले अंतिम मान को निर्दिष्ट करता है।

आइए एक और उदाहरण देखें जहाँ अक्षर निकाले जाते हैं।

final.value <- substring('Remaining', 3, 9)
print(final.value)संचालित द्वारा

ऊपर के कोड में, 'Remaining' एक स्ट्रिंग है जहाँ पहला इंडेक्स 'R' है, जिसका इंडेक्स पूर्णांक 1 है। अंतिम अक्षर g है जिसका इंडेक्स 9 है।

ऊपर का कोड नीचे जैसा आउटपुट दिखाता है जहाँ प्रारंभिक मान पूर्णांक 3 है, जिसका संबद्ध अक्षर 'Remaining' में ' m ' है। इसी तरह, अन्य अक्षर 'ainin' पूर्णांक 9 तक, जो 'g' अक्षर सहित है, प्रिंट हो जाते हैं।

"maining"संचालित द्वारा

आइए एक और उदाहरण देखें जहाँ अक्षरों को प्रतिस्थापित किया जाता है।

y = "Remaining"
substring(y, 3, 5) <- "der"
print(y)संचालित द्वारा

ऊपर का कोड वह आउटपुट दिखाता है जहाँ 3 से 5 तक के प्रारंभिक पूर्णांक मानों के अनुरूप y में जो अक्षर हैं, वे 'der' से बदल दिए जाते हैं।

"Rederning"संचालित द्वारा

substring(char, first, last = 1000000L): किसी कैरेक्टर स्ट्रिंग का निष्कर्षण या प्रतिस्थापन।
ऊपर दिए आर्ग्युमेंट्स का अर्थ:

1. char- एक कैरेक्टर स्ट्रिंग दर्शाता है।
2. first - ऐसा पूर्णांक जो लौटाए जाने वाले पहले मान को निर्दिष्ट करता है।
3. last - ऐसा पूर्णांक जो लौटाए जाने वाले अंतिम मान को निर्दिष्ट करता है और डिफ़ॉल्ट 1000000L है।

my.value <- substring('Remaining', 3, 8)
print(my.value)संचालित द्वारा

ऊपर का कोड नीचे जैसा आउटपुट दिखाता है जहाँ प्रारंभिक मान पूर्णांक 3 है, जिसका संबद्ध अक्षर 'Remaining' में ' m ' है। इसी प्रकार, अन्य अक्षर पूर्णांक 8 तक, जो 'n' अक्षर सहित है, प्रिंट हो जाते हैं।

"mainin"संचालित द्वारा

आइए एक और उदाहरण देखें जहाँ अक्षरों को प्रतिस्थापित किया जाता है।

y = "newcharacter"
substring(y, 6,9) <- "???"
print(y)संचालित द्वारा

ऊपर का कोड वह आउटपुट दिखाता है जहाँ 6 से 9 तक के प्रारंभिक पूर्णांक मानों के अनुरूप y में जो अक्षर हैं, वे '???' से बदल दिए जाते हैं।

"newch???cter"संचालित द्वारा

स्ट्रिंग का फ़ॉर्मेटिंग

format(char,width,scientific,justify,nsmall,digits): यह पूर्णांकों और कैरेक्टर के वेक्टर को सामान्यतः प्रयुक्त फ़ॉर्मेट में बदलता है।

ऊपर दिए आर्ग्युमेंट्स का अर्थ:

1. char - पूर्णांकों या कैरेक्टर्स का वेक्टर हो सकता है।
2. width - बनाई गई स्ट्रिंग की न्यूनतम चौड़ाई दर्शाता है।
3. scientific - डिफ़ॉल्ट FALSE, वैज्ञानिक संकेतन के लिए TRUE करें।
4. justify - डिफ़ॉल्ट none, लेकिन स्ट्रिंग्स को "right", "left", और "center" में दिखा सकता है।
5. nsmall - दशमलव के बाद कुल अंकों की संख्या दर्शाता है
6. digits - दशमलव से पहले और बाद के कुल अंकों की संख्या दर्शाता है।

वैज्ञानिक संकेतन के लिए स्ट्रिंग फ़ॉर्मेटिंग का उदाहरण लें।

my.var <- format(c(2, 19.267), scientific = TRUE)
print(my.var)संचालित द्वारा

ऊपर का कोड वह आउटपुट दिखाता है, जो वैज्ञानिक या घातांक (exponential) संकेतन में व्यक्त होता है

"2.0000e+00" "1.9267e+01"संचालित द्वारा

आउटपुट "1.9267e+01" = 1.9267 x 10 (घात 1) = 1.9267 x 10 = 19.267।

nsmall का उपयोग करते हुए फ़ॉर्मेटिंग का उदाहरण लें।

my.var <- format(92.56656577, nsmall = 6)
print(my.var)संचालित द्वारा

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ दशमलव के बाद 6 अंक शामिल हैं।

"92.566565"संचालित द्वारा

digits का उपयोग करते हुए फ़ॉर्मेटिंग का उदाहरण लें।

my.var <- format(102.848793834, digits = 7)
print(my.var)संचालित द्वारा

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ दशमलव से पहले के अंकों सहित दशमलव के बाद तक कुल अंकों की गिनती के साथ मान दिखाया गया है।

"102.8488"संचालित द्वारा

आउटपुट में सात अंक शामिल हैं, जहाँ अंतिम अंक 7 होना चाहिए था, पर पिछले अंक यानी 9 बड़ा होने के कारण यह 8 हो गया। सरल शब्दों में, राउंड-ऑफ हो गया।

right justify का उपयोग करते हुए फ़ॉर्मेटिंग का उदाहरण लें।

my.var <- format('Running', justify = 'r',width = 9)
print(my.var)संचालित द्वारा

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ 'Running' शब्द को दाईं ओर जस्टिफाई किया गया है और कुछ चौड़ाई का स्पेस जोड़ा गया है।

"  Running"संचालित द्वारा

justify कैरेक्टर को center में उपयोग करते हुए फ़ॉर्मेटिंग का उदाहरण लें।

my.var <- format('Running', justify = 'c',width = 12)
print(my.var)संचालित द्वारा

ऊपर का कोड नीचे जैसा आउटपुट देता है जहाँ 'Running' शब्द को बीच में जस्टिफाई किया गया है और दाएँ-बाएँ समान चौड़ाई का स्पेस है।

"  Running   "संचालित द्वारा

बधाई हो

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं!

आपने R की स्ट्रिंग्स के बारे में सीखा: उनके नियम, संयोजन, स्ट्रिंग की आवश्यक विशेषताएँ, किसी कैरेक्टर स्ट्रिंग का निष्कर्षण और प्रतिस्थापन, तथा स्ट्रिंग का फ़ॉर्मेटिंग।

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

हमारा Data Types in R ट्यूटोरियल देखें।