मुख्य सामग्री पर जाएँ

R रेगुलर एक्सप्रेशन (Regex) पर मार्गदर्शिका

R में रेगुलर एक्सप्रेशन, उनका महत्व, उनसे काम करने के टूल और फ़ंक्शन, सामान्य regex पैटर्न, और उनका उपयोग जानें।
· 12 मि॰ पढ़ें

AI के साथ खोजें

रेगुलर एक्सप्रेशन का सिद्धांत, जिसे आमतौर पर regex कहा जाता है, कई प्रोग्रामिंग भाषाओं जैसे R, Python, C, C++, Perl, Java, और JavaScript में मौजूद है। आप इन भाषाओं के बेस संस्करण में या लाइब्रेरी के माध्यम से regex की सुविधा का उपयोग कर सकते हैं। अधिकांश भाषाओं में regex पैटर्न का सिंटैक्स समान होता है।

इस ट्यूटोरियल में, हम देखेंगे कि R में रेगुलर एक्सप्रेशन क्या हैं, वे क्यों महत्वपूर्ण हैं, किन टूल और फ़ंक्शन्स से हम उनके साथ काम कर सकते हैं, सबसे सामान्य regex पैटर्न कौन से हैं, और उन्हें कैसे उपयोग करें। अंत में, हम R regex के कुछ उन्नत उपयोगों का अवलोकन करेंगे।

R Regex क्या हैं और आपको उनका उपयोग क्यों करना चाहिए?

R में एक रेगुलर एक्सप्रेशन, regex, वर्णों का एक अनुक्रम (कभी-कभी केवल एक वर्ण) होता है जो किसी पाठ में पाए जाने वाले किसी विशेष पैटर्न का वर्णन करता है। Regex पैटर्न उतने छोटे हो सकते हैं जितना कि ‘a’ या उतने लंबे जितना कि इस StackOverflow थ्रेड में उल्लिखित है।

व्यापक रूप से कहें तो, regex की ऊपर दी गई परिभाषा केवल R तक सीमित नहीं है, बल्कि किसी भी अन्य भाषा पर लागू होती है जो रेगुलर एक्सप्रेशन का समर्थन करती है।

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

R Regex के साथ काम करने के टूल और फ़ंक्शन्स

हालांकि अधिकांश भाषाओं में regex पैटर्न समान होते हैं, लेकिन उनके साथ काम करने के लिए उपलब्ध फ़ंक्शन्स अलग-अलग होते हैं।

R में, हम बेस R के फ़ंक्शन्स का उपयोग करके regex को डिटेक्ट, मैच, लोकेट, एक्सट्रैक्ट और रिप्लेस कर सकते हैं। नीचे मुख्य फ़ंक्शन्स दिए गए हैं जो किसी कैरेक्टर वेक्टर में regex मैच ढूंढते हैं और फिर निम्न कार्य करते हैं:

  • grep(), grepl() – grep() मैच रखने वाली स्ट्रिंग्स के इंडेक्स लौटाता है, जबकि grepl() एक लॉजिकल वेक्टर देता है जो दिखाता है कि किन स्ट्रिंग्स में मैच है।

  • regexpr(), gregexpr() – प्रत्येक स्ट्रिंग में वह इंडेक्स लौटाते हैं जहाँ मैच शुरू होता है और उस मैच की लंबाई। regexpr() यह जानकारी केवल पहले (बाएँ से) मैच के लिए देता है, जबकि gregexpr() यह जानकारी सभी मैचों के लिए देता है।

  • sub(), gsub() – प्रत्येक स्ट्रिंग में डिटेक्ट किए गए मैच को किसी निर्दिष्ट स्ट्रिंग से बदलते हैं (sub() – केवल पहले मैच के लिए, gsub() – सभी मैचों के लिए)।

  • regexec() – regexpr() जैसा काम करता है, पर साथ ही मैच के भीतर किसी निर्दिष्ट सब-एक्सप्रेशन के लिए भी वही जानकारी देता है।

  • regmatches() – regexec() जैसा काम करता है, पर समग्र मैच और किसी निर्दिष्ट सब-एक्सप्रेशन के लिए डिटेक्ट हुई सटीक स्ट्रिंग्स लौटाता है।

हालांकि, नेटिव R फ़ंक्शन्स के बजाय, R regex के साथ काम करने का एक अधिक सुविधाजनक और सुसंगत तरीका है stringr पैकेज का उपयोग करना, जो tidyverse संग्रह का हिस्सा है। यह लाइब्रेरी stringi पैकेज के ऊपर बनी है। stringr लाइब्रेरी में, सभी फ़ंक्शन्स str_ से शुरू होते हैं और इनके नाम (तथा वैकल्पिक पैरामीटर्स के नाम) बेस R की तुलना में कहीं अधिक सहज होते हैं।

stringr पैकेज को इंस्टॉल और लोड करने के लिए, निम्न चलाएँ:

install.packages('stringr')
library(stringr)

नीचे दी गई तालिका में stringr फ़ंक्शन्स और इस सेक्शन में पहले चर्चा किए गए बेस R फ़ंक्शन्स के बीच का संबंध दिखाया गया है:

stringr

Base R

str_subset()

grep()

str_detect()

grepl()

str_extract()

regexpr(), regmatches(), grep()

str_match()

regexec()

str_locate()

regexpr()

str_locate_all()

gregexpr()

str_replace()

sub()

str_replace_all()

gsub()

stringr फ़ंक्शन्स और रेगुलर एक्सप्रेशन्स की पूरी सूची आपको इन चीट शीट्स में मिलेगी, लेकिन हम इस ट्यूटोरियल में आगे इनमें से कुछ पर चर्चा करेंगे।

ध्यान दें: stringr फ़ंक्शन्स में, हम पहले डेटा और फिर regex पास करते हैं, जबकि बेस R फ़ंक्शन्स में – इसके उलट।

एक और ध्यान दें: इस ट्यूटोरियल में stringr 1.5.1 का उपयोग किया गया है, जो 2026 तक का वर्तमान संस्करण है। यदि आप पुराना संस्करण उपयोग कर रहे हैं, तो कुछ व्यवहार भिन्न हो सकते हैं — खासकर str_view() के आसपास, जिसे 1.5.0 में काफी अपडेट किया गया था।

R Regex पैटर्न

अब, हम सबसे लोकप्रिय R regex पैटर्न्स और उनके उपयोग का अवलोकन करेंगे और साथ ही कुछ stringr फ़ंक्शन्स का अभ्यास भी करेंगे।

इससे पहले, एक बहुत बुनियादी उदाहरण देखें। यानी, जाँचें कि क्या एक unicorn के पास कम से कम एक corn है 😉

str_detect('unicorn', 'corn')

आउटपुट:

TRUE

इस उदाहरण में, हमने unicorn स्ट्रिंग में corn स्ट्रिंग की उपस्थिति जाँचने के लिए stringr फ़ंक्शन str_detect() का उपयोग किया।

हालाँकि, प्रायः हम किसी निश्चित लिटरल स्ट्रिंग की नहीं, बल्कि किसी पैटर्न — यानी रेगुलर एक्सप्रेशन — की तलाश करते हैं। आइए ऐसे पैटर्न्स में गोता लगाएँ।

कैरेक्टर एस्केप्स

R रेगुलर एक्सप्रेशन्स में कुछ वर्ण ऐसे होते हैं जिनका एक विशेष अर्थ होता है। यानी वे अपने आप से मेल नहीं खाते, जैसा कि सभी अक्षर और अंक करते हैं, बल्कि कुछ अलग करते हैं:

str_extract_all('unicorn', '.')

आउटपुट:

1. 'u' 'n' 'i' 'c' 'o' 'r' 'n'

हम साफ़ देखते हैं कि हमारे unicorn में कोई डॉट नहीं है। फिर भी, str_extract_all() फ़ंक्शन ने इस स्ट्रिंग के हर एक कैरेक्टर को निकाला। यही . कैरेक्टर का मिशन है — नई पंक्ति छोड़कर किसी भी एकल कैरेक्टर से मेल खाना।

यदि हम एक लिटरल डॉट निकालना चाहें तो? इसके लिए हमें डॉट से पहले एक regex एस्केप कैरेक्टर — बैकस्लैश (\\) — उपयोग करना होगा। पर यहाँ एक पेचीदगी है: बैकस्लैश स्वयं स्ट्रिंग्स में एस्केप कैरेक्टर की तरह उपयोग होता है। यानी हमें पहले “एस्केप कैरेक्टर को ही एस्केप” करना होगा — डबल बैकस्लैश उपयोग करके। देखें यह कैसे काम करता है:

str_extract_all('Eat. Pray. Love.', '\\.')

आउटपुट:

1. '.' '.' '.'

अतः, बैकस्लैश कुछ प्रतीकों के विशेष अर्थ को हटाने और उन्हें लिटरली इंटरप्रेट कराने में मदद करता है। इसका उल्टा मिशन भी है: ऐसे कुछ कैरेक्टर्स को विशेष अर्थ देना जो अन्यथा लिटरली इंटरप्रेट होते। नीचे सबसे अधिक इस्तेमाल होने वाले कैरेक्टर एस्केप सिक्वेन्सेस की तालिका है:

R regex

किससे मेल खाता है

\\b

शब्द सीमा (\\w और \\W के बीच की सीमा)

\\B

गैर-शब्द सीमा (\\w-\\w या \\W-\\W)

\\n

नई पंक्ति

\\t

टैब

\\v

वर्टिकल टैब

कुछ उदाहरण देखें, ध्यान रहे कि ऐसे मामलों में भी हमें डबल बैकस्लैश का उपयोग करना है। साथ ही, हम एक और stringr फ़ंक्शन पेश करेंगे: str_view(), जिससे पहले मैच या सभी मैचों का HTML रेंडरिंग देखा जा सकता है:

str_view('Unicorns are so cute!', 's\\\b')
str_view('Unicorns are so cute!', 's\\\B')

आउटपुट:

Unicorns are so cute!
Unicorns are so cute!

Unicorns are so cute! स्ट्रिंग में अक्षर s के दो उदाहरण हैं। ऊपर, पहले R regex पैटर्न ने अक्षर s के पहले उदाहरण को हाईलाइट किया (क्योंकि उसके बाद स्पेस है), जबकि दूसरे पैटर्न ने दूसरे उदाहरण को (क्योंकि उसके बाद दूसरा अक्षर है, शब्द सीमा नहीं)।

कुछ और उदाहरण:

cat('Unicorns are\\nso cute!')
str_view('Unicorns are\\nso cute!', '\\\\n')

आउटपुट:

Unicorns are
so cute!

Unicorns are_so cute!

cat('Unicorns are\\tso cute!')
str_view('Unicorns are\\tso cute!', '\\\\t')

आउटपुट:

Unicorns are so    cute!

Unicorns are_so cute!

कैरेक्टर क्लासेस

कैरेक्टर क्लास एक पूर्वनिर्धारित सेट के किसी भी कैरेक्टर से मेल खाता है। बिल्ट-इन कैरेक्टर क्लासेस का सिंटैक्स उन्हीं कैरेक्टर एस्केप सिक्वेन्सेस जैसा होता है जिन्हें हमने पिछले सेक्शन में देखा: बैकस्लैश के बाद एक अक्षर, जिसे वह लिटरल अर्थ के बजाय विशेष अर्थ देता है। इनके सबसे लोकप्रिय रूप नीचे दिए गए हैं:

R regex

किससे मेल खाता है

\\w

कोई भी शब्द कैरेक्टर (कोई अक्षर, अंक, या अंडरस्कोर)

\\W

कोई भी गैर-शब्द कैरेक्टर

\\d

कोई भी अंक

\\D

कोई भी गैर-अंक

\\s

कोई भी स्पेस कैरेक्टर (स्पेस, टैब, नई पंक्ति, आदि)

\\S

कोई भी गैर-स्पेस कैरेक्टर

कुछ स्वयं-स्पष्ट उदाहरण देखें:

str_view('Unicorns are so cute!', '\\\\w')
str_view('Unicorns are so cute!', '\\\\W')

आउटपुट:

[1] │ <U><n><i><c><o><r><n><s>< ><a><r><e>< ><s><o>< ><c><u><t><e>!
[1] │ Unicorns< >are< >so< >cute<!>
str_view('Unicorns are\\nso cute!', '\\\\s')
str_view('Unicorns are\\nso cute!', '\\\\S')

आउटपुट:

Unicorns are<\\n>so cute!

str_detect('Unicorns are so cute!', '\\\\d')

आउटपुट:

FALSE

बिल्ट-इन कैरेक्टर क्लासेस एक वैकल्पिक रूप में भी दिखाई दे सकते हैं — [:character_class_name:]। इनमें से कुछ के बैकस्लैश वाले समकक्ष होते हैं; कुछ के नहीं। सबसे सामान्य ये हैं:

R regex

किससे मेल खाता है

[:alpha:]

कोई भी अक्षर

[:lower:]

कोई भी लोअरकेस अक्षर

[:upper:]

कोई भी अपरकेस अक्षर

[:digit:]

कोई भी अंक (\\d के समकक्ष)

[:alnum:]

कोई भी अक्षर या संख्या

[:xdigit:]

कोई भी हेक्साडेसिमल अंक

[:punct:]

कोई भी विराम चिह्न

[:graph:]

कोई भी अक्षर, संख्या, या विराम चिह्न

[:space:]

स्पेस, टैब, नई पंक्ति, आदि (\\s के समकक्ष)

कुछ उदाहरण देखें, ध्यान रहे कि हमें ऊपर दिए गए किसी भी R regex पैटर्न को स्क्वायर ब्रैकेट्स के भीतर रखना होगा:

str_view('Unicorns are so cute!', '[[:upper:]]')
str_view('Unicorns are so cute!', '[[:lower:]]')

आउटपुट:

Unicorns are so cute!

Unicorns are so cute!

str_detect('Unicorns are so cute!', '[[:digit:]]')

आउटपुट:

FALSE
str_extract_all('Unicorns are so cute!', '[[:punct:]]')

आउटपुट:

1. '!'
str_view('Unicorns are so cute!', '[[:space:]]')

आउटपुट:

Unicorns_are_so_cute!

यूज़र-परिभाषित कैरेक्टर क्लास भी बनाना संभव है — स्क्वायर ब्रैकेट्स के भीतर हम किसी भी ऐसे कैरेक्टर्स के सेट को रख सकते हैं जिनमें से हम किसी एक से मैच करना चाहते हैं। हम स्क्वायर ब्रैकेट्स में अक्षरों या संख्याओं की रेंज (यूनिकोड क्रम में), कई अलग-अलग रेंज, या किसी भी क्रमागत/अक्रमागत कैरेक्टर्स या कैरेक्टर समूहों का सेट रख सकते हैं।

उदाहरण के लिए, [A-D] A से D तक किसी भी अपरकेस अक्षर से मेल खाएगा, [k-r] — k से r तक किसी भी लोअरकेस अक्षर से, [0-7] — 0 से 7 तक किसी भी अंक से, और [aou14%9] — स्क्वायर ब्रैकेट्स के भीतर दिए किसी भी कैरेक्टर से। यदि हम स्क्वायर ब्रैकेट्स के भीतर पहले कैरेक्टर के रूप में कैरेट (⁠^) रखें, तो हमारा R regex पैटर्न दिए गए कैरेक्टर्स को छोड़कर बाकी सब से मेल खाएगा। ध्यान दें कि ऊपर बताए गए मिलान तंत्र केस-सेंसिटिव हैं।

str_view('Unicorns Are SOOO Cute!', '[O-V]')
str_view('Unicorns Are SOOO Cute!', '[^O-V]')

आउटपुट:

Unicorns Are SOOO Cute!

Unicorns Are SOOO Cute!

str_view('3.14159265359', '[0-2]')

आउटपुट:

3.14159265359

str_view('The number pi is equal to 3.14159265359', '[n2e9&]')

आउटपुट:

The number pi is equal to 3.14159265359

क्वांटिफ़ायर्स

अक्सर, हमें किसी R regex पैटर्न का बार-बार मिलान कराना होता है, न कि केवल एक बार। इसके लिए हम क्वांटिफ़ायर्स का उपयोग करते हैं। क्वांटिफ़ायर हमेशा उस regex पैटर्न के बाद आता है जिससे वह संबंधित होता है। सबसे सामान्य क्वांटिफ़ायर्स नीचे दी गई तालिका में हैं:

R regex

पैटर्न दोहराव की संख्या

*

0 या अधिक

+

कम से कम 1

?

अधिकतम 1

{n}

सटीक n

{n,}

कम से कम n

{n,m}

कम से कम n और अधिकतम m

इन्हें आजमाएँ:

str_extract('dog', 'dog\\\\d*')

आउटपुट:

'dog'

हमें शुरुआती स्ट्रिंग dog मिली: उस स्ट्रिंग के अंत में कोई अंक नहीं है, लेकिन हम इसके साथ ठीक हैं (0 या अधिक अंकों के उदाहरण)।

str_extract('12345', '\\\\d+')

आउटपुट:

'12345'
str_extract('12345', '\\\\d?')

आउटपुट:

'1'
str_extract('12345', '\\\\d{3}')

आउटपुट:

'123'
str_extract('12345', '\\\\d{7,}')

आउटपुट:

NA

हमें NA मिला क्योंकि स्ट्रिंग में कम से कम 7 अंक नहीं हैं, केवल 5 हैं।

str_extract('12345', '\\\\d{2,4}')

आउटपुट:

'1234'

एंकर्स

डिफ़ॉल्ट रूप से, R regex दी गई स्ट्रिंग के किसी भी हिस्से से मेल खा सकता है। हम किसी R regex पैटर्न की स्ट्रिंग के भीतर स्थिति निर्दिष्ट करके इस व्यवहार को बदल सकते हैं। अक्सर, हम स्ट्रिंग की शुरुआत या अंत से मैच कराना चाहते हैं। इसके लिए, R रेगुलर एक्सप्रेशन्स में दो मुख्य एंकर्स होते हैं:

  • ^ – स्ट्रिंग की शुरुआत से मैच करता है (मल्टीलाइन स्ट्रिंग्स में — प्रत्येक लाइन की शुरुआत से)

  • $ – स्ट्रिंग के अंत से मैच करता है (मल्टीलाइन स्ट्रिंग्स में — प्रत्येक लाइन के अंत से)

इन्हें palindrome stella won no wallets के उदाहरण पर देखें:

str_view('stella won no wallets', '^s')
str_view('stella won no wallets', 's$')

आउटपुट:

<s>tella won no wallets
stella won no wallet<s>

यदि हम स्वयं ^ या $ कैरेक्टर्स से मैच करना चाहें, तो हमें उस कैरेक्टर के पहले बैकस्लैश (डबलिंग करते हुए) लगाना होगा:

str_view('Do not have 100$, have 100 friends', '\\\\$')

आउटपुट:

Do not have 100$, have 100 friends

स्ट्रिंग के भीतर शब्द सीमा या गैर-शब्द सीमा पर भी एंकर करना संभव है (\\b और \\B क्रमश:):

str_view('road cocoa oasis oak boa coach', '\\\\boa')
str_view('road cocoa oasis oak boa coach', 'oa\\\\b')
str_view('road cocoa oasis oak boa coach', 'oa\\\\B')

आउटपुट:

road cocoa oasis oak boa coach

road cocoa oasis oak boa coach

road cocoa oasis oak boa coach

ऊपर, हमने अक्षरों के संयोजन oa का मिलान किया:

  • पहला उदाहरण – शब्दों की शुरुआत में
  • दूसरा उदाहरण – शब्दों के अंत में
  • तीसरा उदाहरण – जब उसके बाद कोई शब्द कैरेक्टर हो (हमारे मामले में – कोई अक्षर)

ऑल्टर्नेशन

ऑल्टर्नेशन ऑपरेटर (|) लागू करके, हम एक ही स्ट्रिंग में एक से अधिक R regex पैटर्न्स से मैच करा सकते हैं। ध्यान दें कि यदि हम इस ऑपरेटर को यूज़र-परिभाषित कैरेक्टर क्लास का हिस्सा बनाते हैं, तो उसे लिटरली इंटरप्रेट किया जाता है, अतः वह कोई ऑल्टर्नेशन नहीं करता।

str_view('coach koala board oak cocoa road boa load coat oasis boat', 'boa|coa')

आउटपुट:

coach koala board oak cocoa road boa load coat oasis boat

ऊपर के उदाहरण में, हमने boa या coa में से किसी भी के सभी उदाहरणों का मिलान किया।

ग्रूपिंग

R regex पैटर्न्स कुछ प्रीसिडेंस नियमों का पालन करते हैं। उदाहरण के लिए, पुनरावृत्ति (क्वांटिफ़ायर्स का उपयोग) एंकरिंग पर वरीयता रखती है, जबकि एंकरिंग को ऑल्टर्नेशन पर वरीयता मिलती है। इन नियमों को ओवरराइड करने और किसी विशेष ऑपरेशन की प्रीसिडेंस बढ़ाने के लिए, हमें ग्रूपिंग का उपयोग करना चाहिए। यह इच्छित सब-एक्सप्रेशन को राउंड ब्रैकेट्स में बंद करके किया जा सकता है।

ग्रूपिंग, ऑल्टर्नेशन ऑपरेटर के साथ मिलकर सबसे अच्छा काम करती है। नीचे के उदाहरण इस संयोजन के प्रभाव को स्पष्ट रूप से दिखाते हैं:

str_view('code rat coat cot cat', 'co|at')
str_view('code rat coat cot cat', 'c(o|a)t')

आउटपुट:

code rat coat cot cat

code rat coat cot cat

R रेगुलर एक्सप्रेशन्स के उन्नत उपयोग

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

  • stringr फ़ंक्शन्स के डिफ़ॉल्ट्स को ओवरराइड करना
  • ग्रैफीम क्लस्टर्स का मिलान
  • ग्रुप बैक-रेफरेंसिंग
  • यूनिकोड प्रॉपर्टीज़ का मिलान
  • उन्नत कैरेक्टर एस्केपिंग लागू करना
  • किसी पैटर्न के अस्तित्व की पुष्टि करना बिना उसे आउटपुट में शामिल किए (जिसे lookarounds कहा जाता है)
  • पैटर्न के पुनरावृत्ति तंत्र को ग्रीडी के बजाय लेज़ी बनाना
  • एटॉमिक ग्रुप्स के साथ काम करना

हमारे कोर्स Intermediate Regular Expressions in R में और जानें।

R Regex चैलेंज

अब बारी आपकी है कि आप इस ट्यूटोरियल में चर्चा किए गए R regex पैटर्न्स का अभ्यास करें। इसके लिए हमारे Dataset: Internet News and Consumer Engagement का उपयोग करें, और निम्न कार्य करने की कोशिश करें: सभी URLs से टॉप-लेवल डोमेन्स (TLDs) निकालें। TLDs के कुछ उदाहरण हैं com, net, uk, आदि।

इस कार्य को पूरा करने के एक से अधिक तरीके हैं, जिनमें सुगठित और कॉम्पैक्ट वन-लाइन समाधान भी शामिल हैं (संकेत: आप पिछले सेक्शन में उल्लिखित R regex में lookarounds के बारे में और सीख सकते हैं और उन्हें इस समस्या को हल करने में उपयोग कर सकते हैं)। एक अपेक्षाकृत “नवोदित” दृष्टिकोण के लिए निम्न बहुत ढीली रूपरेखा पर विचार करें:

  • डेटासेट में कुछ URLs देखें और ध्यान दें कि TLD से पहले कौन से पैटर्न किसी भी URL में हमेशा मौजूद होते हैं और कौन से वैकल्पिक होते हैं
  • देखें कि TLD के बाद किसी भी URL में कोई अनिवार्य पैटर्न हैं (और यदि हैं, तो कौन से) और कौन से पैटर्न वैकल्पिक हैं
  • URL के TLD से पहले की हर चीज़ हटा दें
  • URL के TLD के बाद की हर चीज़ हटा दें

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

बोनस: चैलेंज #2

यदि आप बिना किसी संकेत के और अभ्यास करना चाहते हैं, तो इस बार निम्न करें: पिछले चैलेंज वाले उसी डेटासेट का उपयोग करते हुए, सभी URLs से डोमेन नाम निकालें। उदाहरण के लिए, URL www.google.com में डोमेन नाम google है।

निष्कर्ष

समापन में, इस ट्यूटोरियल में हमने R रेगुलर एक्सप्रेशन्स के बारे में कई बातें सीखीं। खास तौर पर, हमने चर्चा की:

  • R regex क्या हैं
  • वे क्यों महत्वपूर्ण हैं और कहाँ लागू होते हैं
  • R रेगुलर एक्सप्रेशन्स के साथ काम करने हेतु (नेटिव R और एक विशेष लाइब्रेरी के) कौन से फ़ंक्शन्स उपयोग होते हैं
  • सबसे सामान्य R regex पैटर्न्स और उनका दायरा, सूक्ष्मताएँ, और पेचीदगियाँ
  • R regex के साथ कैरेक्टर एस्केप्स, कैरेक्टर क्लासेस, क्वांटिफ़ायर्स, एंकर्स, ऑल्टर्नेशन, और ग्रूपिंग का कब और कैसे उपयोग करें
  • R regex और फ़ंक्शन्स के विभिन्न उपयोग-उदाहरण
  • R रेगुलर एक्सप्रेशन्स के कुछ उन्नत ऑपरेशन्स

ये कौशल और अवधारणाएँ R में और कई अन्य भाषाओं में भी आपकी मदद करेंगी, क्योंकि रेगुलर एक्सप्रेशन की अवधारणा सभी भाषाओं में समान है और अधिकांश में regex का सिंटैक्स भी काफी मिलता-जुलता है।

यदि आप अपनी R स्किल्स को मास्टर करना चाहते हैं, तो DataCamp के निम्न कोर्सेज़, स्किल ट्रैक्स, और आर्टिकल्स देखें:

Elena Kosourova

लेखक

Elena Kosourova

LinkedIn

IBM प्रमाणित डेटा साइंटिस्ट (2020); इससे पहले विश्वभर में तेल और गैस क्षेत्रों के पेट्रोलियम भूविज्ञानी/जियोमॉडलर, 12+ वर्षों के अंतरराष्ट्रीय कार्य अनुभव के साथ। Python, R और SQL में दक्ष। विशेषज्ञता के क्षेत्र: डेटा क्लीनिंग, डेटा मैनिपुलेशन, डेटा विज़ुअलाइज़ेशन, डेटा विश्लेषण, डेटा मॉडलिंग, सांख्यिकी, स्टोरीटेलिंग, मशीन लर्निंग। डेटा साइंस समुदायों का प्रबंधन करने और डेटा साइंस व करियर विषयों पर लेखों व ट्यूटोरियल्स के लेखन/समीक्षा में व्यापक अनुभव।

FAQs

मैं कैसे जाँचूँ कि मेरे पास stringr का कौन सा संस्करण है, और उसे कैसे अपडेट करूँ?

अपने R कंसोल में यह चलाएँ:

packageVersion('stringr')

यदि यह 1.5.0 से कम कुछ दिखाए, तो अपडेट करें:

install.packages('stringr')
 
क्या str_view_all() पूरी तरह काम करना बंद कर देगा, या फिलहाल इसे इस्तेमाल करना सुरक्षित है?

यह stringr के वर्तमान संस्करण में अब भी काम करता है और कुछ समय तक करता रहेगा — R में deprecation का मतलब तुरंत हटाना नहीं होता। हालांकि, हर कॉल एक वार्निंग संदेश देगी, जो जल्दी ही शोरगुल भरा हो जाता है। अधिक महत्वपूर्ण यह कि डिप्रिकेटेड फ़ंक्शन्स अंततः भविष्य की मेजर रिलीज़ में हटा दिए जाते हैं, तो str_view_all() पर निर्भर कोई भी कोड अंततः टूट जाएगा। इसे ठीक करने में लगभग 30 सेकंड लगते हैं, इसलिए अभी कर लेना बेहतर है।

R regex में मुझे डबल बैकस्लैश (\\) की ज़रूरत क्यों होती है, जबकि दूसरी भाषाओं में सिर्फ एक ही चलता है?

उत्तर: क्योंकि R, regex इंजन तक पहुँचने से पहले स्ट्रिंग को प्रोसेस करता है। एक अकेला \ R के स्ट्रिंग पार्सर द्वारा खप जाता है, इसलिए यह सुनिश्चित करने के लिए कि एक अकेला \ वास्तव में regex इंजन तक पहुँचे, आपको \\ की ज़रूरत होती है। आप \\d लिखते हैं और R उसे regex के लिए \d में बदल देता है — आप \d लिखेंगे तो regex तक पहुँचने से पहले ही टूट जाएगा।

base R में grep() और grepl() में क्या फर्क है, और मुझे किसका उपयोग करना चाहिए?

grep() मैच करने वाले एलिमेंट्स के इंडेक्स लौटाता है; grepl() आपके इनपुट की ही लंबाई का TRUE/FALSE वेक्टर देता है। जब आपको पोजीशन चाहिए तो grep() उपयोग करें, फ़िल्टर या जाँच के लिए grepl()। व्यवहार में, stringr के समकक्ष str_subset() और str_detect() ज़्यादातर उपयोग-केस में अधिक साफ़-सुथरे हैं।

मुझे [aeiou] जैसी कैरेक्टर क्लास कब उपयोग करनी चाहिए और a|e|i|o|u जैसा ऑल्टर्नेशन कब?

एकल कैरेक्टर के लिए हमेशा कैरेक्टर क्लास का उपयोग करें — यह तेज़ और सुव्यवस्थित है। | के साथ ऑल्टर्नेशन तब उपयोग करें जब आपके किसी विकल्प में एक से अधिक कैरेक्टर हों, जैसे cat|dog, क्योंकि ऐसे पैटर्न [] के भीतर नहीं रखे जा सकते।

*, +, और ? क्वांटिफ़ायर्स में क्या अंतर है?

* = शून्य या अधिक (पैटर्न वैकल्पिक है और दोहर सकता है)। + = एक या अधिक (कम से कम एक आवश्यक)। ? = शून्य या एक (वैकल्पिक, दोहरता नहीं)। याद रखने की युक्ति: + जोड़ता है (कम से कम एक चाहिए), ? पूछता है (हो भी सकता है, नहीं भी), * मतलब कुछ भी चलेगा।

sub() और gsub() में क्या फर्क है, और उनके stringr समकक्ष क्या हैं?

sub() केवल पहले मैच को बदलता है; gsub() सभी मैचों को। इनके stringr समकक्ष हैं str_replace() और str_replace_all()। stringr संस्करण बेहतर हैं क्योंकि वे tidyverse के आर्गुमेंट क्रम का पालन करते हैं — पहले डेटा, फिर पैटर्न, तीसरा रिप्लेसमेंट।

base R में regexpr() बनाम gregexpr() का उपयोग कब करूँ?

regexpr() प्रत्येक स्ट्रिंग में पहले मैच की स्थिति ढूँढता है; gregexpr() सभी मैच ढूँढता है। अधिकांश R उपयोगकर्ता इसके बजाय stringr के str_locate() और str_locate_all() पसंद करते हैं — ये बेस R के जटिल नामित इंटिजर फ़ॉर्मेट के बजाय start और end कॉलम वाले साफ़ डेटा फ़्रेम के रूप में परिणाम देते हैं।

स्क्वायर ब्रैकेट्स के अंदर ^ का मतलब क्या है, और बाहर होने पर क्या?

[] के बाहर, यह स्ट्रिंग की शुरुआत पर एंकर करता है: ^Hello उन स्ट्रिंग्स से मेल खाता है जो "Hello" से शुरू होती हैं। [] के भीतर पहले कैरेक्टर के रूप में, यह सेट को नकारता है: [^aeiou] किसी भी ऐसे कैरेक्टर से मेल खाता है जो स्वर नहीं है। [] के भीतर अन्य किसी जगह यह एक लिटरल कैरेट माना जाता है।

मैं ^ और $ एंकर्स की बजाय \b वर्ड बाउंड्रीज़ कब उपयोग करूँ?

जब आप किसी शब्द को पूरे शब्द के रूप में स्ट्रिंग में कहीं भी मिलाना चाहें, न कि केवल शुरुआत या अंत पर, तब \b का उपयोग करें। cat ढूँढने पर "concatenated" भी मैच हो जाएगा — \bcat\b केवल अलग-थलग खड़े शब्द से ही मैच करेगा। टेक्स्ट विश्लेषण में यह खास तौर पर उपयोगी है जब आंशिक मैच आपके परिणामों को बिगाड़ सकते हैं।

विषय

R