R Language
पैटर्न मिलान और प्रतिस्थापन

परिचय

वाक्य - विन्यास

• grep ("क्वेरी", "विषय", वैकल्पिक_कार)

• grepl ("क्वेरी", "विषय", वैकल्पिक_कार)

• gsub ("(group1) (group2)", "\\ group #", "विषय")

टिप्पणियों

स्थानापन्न बनाना

# example data
test_sentences <- c("The quick brown fox quickly", "jumps over the lazy dog")

आइए भूरा लोमड़ी लाल करें:

sub("brown","red", test_sentences)
#[1] "The quick red fox quickly"       "jumps over the lazy dog"

अब, चलो "fast" लोमड़ी अधिनियम "fastly" "fast" बनाते हैं। यह ऐसा नहीं करेगा:

sub("quick", "fast", test_sentences)
#[1] "The fast red fox quickly"       "jumps over the lazy dog"

sub केवल पहले उपलब्ध प्रतिस्थापन बनाता है, हमें वैश्विक प्रतिस्थापन के लिए gsub आवश्यकता है:

gsub("quick", "fast", test_sentences)
#[1] "The fast red fox fastly"       "jumps over the lazy dog"

अधिक उदाहरणों के लिए प्रतिस्थापन द्वारा तारों को संशोधित करना देखें।

माचिस ढूंढना

# example data
test_sentences <- c("The quick brown fox", "jumps over the lazy dog")   

क्या कोई मेल है?

grepl() का उपयोग यह जांचने के लिए किया जाता है कि एक स्ट्रिंग या वर्ण वेक्टर में एक शब्द या नियमित अभिव्यक्ति मौजूद है या नहीं। फ़ंक्शन एक TRUE / FALSE (या "बूलियन") वेक्टर देता है।

ध्यान दें कि हम शब्द "लोमड़ी" के लिए प्रत्येक स्ट्रिंग की जांच कर सकते हैं और बदले में एक बूलियन वेक्टर प्राप्त कर सकते हैं।

grepl("fox", test_sentences)
#[1]  TRUE FALSE

स्थानों का मिलान करें

grep एक चरित्र स्ट्रिंग और एक नियमित अभिव्यक्ति में लेता है। यह अनुक्रमित के एक संख्यात्मक वेक्टर को वापस करता है। यह वापस आएगा जिसमें वाक्य में "लोमड़ी" शब्द है।

grep("fox", test_sentences)
#[1] 1

मिलान किए गए मान

पैटर्न से मेल खाने वाले वाक्यों का चयन करने के लिए:

# each of the following lines does the job:
test_sentences[grep("fox", test_sentences)]
test_sentences[grepl("fox", test_sentences)]
grep("fox", test_sentences, value = TRUE)
# [1] "The quick brown fox"

विवरण

चूंकि "fox" पैटर्न एक शब्द है, नियमित अभिव्यक्ति के बजाय, हम fixed = TRUE को निर्दिष्ट करके प्रदर्शन ( grep या grepl ) में सुधार कर सकते हैं।

grep("fox", test_sentences, fixed = TRUE)
#[1] 1

एक पैटर्न से मेल नहीं खाने वाले वाक्यों का चयन करने के लिए, कोई invert = TRUE साथ grep उपयोग कर सकता है; या का पालन subsetting के साथ नियमों -grep(...) या !grepl(...) ।

grepl(pattern, x) और grep(pattern, x) , x पैरामीटर सदिश है , pattern पैरामीटर नहीं है। परिणामस्वरूप, आप x[1] विरुद्ध pattern[1] x[1] के pattern[2] x[2] , और इसी तरह से इनका उपयोग सीधे नहीं कर सकते।

मैचों का सारांश

उदाहरण के लिए grepl कमांड का प्रदर्शन करने के बाद, शायद आप इस बात का अवलोकन करना चाहते हैं कि TRUE या FALSE कितने मैच हैं। यह बड़े डेटा सेट के मामले में उपयोगी है। ऐसा करने के लिए summary कमांड चलाएं:

# example data
test_sentences <- c("The quick brown fox", "jumps over the lazy dog") 

# find matches
matches <- grepl("fox", test_sentences)

# overview
summary(matches)

सिंगल और ग्लोबल मैच।

जब पीसीआर के लिए एक नियमित रूप से अभिव्यक्ति के साथ काम करना वैश्विक मैच के लिए g ।

R मिलान और प्रतिस्थापन कार्यों में दो संस्करण होते हैं: पहला मैच और वैश्विक मैच:

• sub(pattern,replacement,text) पाठ में प्रतिस्थापन द्वारा पैटर्न की पहली घटना को प्रतिस्थापित करेगा

• gsub(pattern,replacement,text) उप के समान ही होगा लेकिन पैटर्न की प्रत्येक घटना के लिए

• regexpr(pattern,text) के पहले उदाहरण के लिए मैच की स्थिति लौटाएगा

• gregexpr(pattern,text) सभी मैच लौटाएगा।

कुछ यादृच्छिक डेटा:

set.seed(123)
teststring <- paste0(sample(letters,20),collapse="")

# teststring
#[1] "htjuwakqxzpgrsbncvyo"

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

sub("[aeiouy]"," ** HERE WAS A VOWEL** ",teststring)
#[1] "htj ** HERE WAS A VOWEL** wakqxzpgrsbncvyo"

gsub("[aeiouy]"," ** HERE WAS A VOWEL** ",teststring)
#[1] "htj ** HERE WAS A VOWEL** w ** HERE WAS A VOWEL** kqxzpgrsbncv ** HERE WAS A VOWEL**  ** HERE WAS A VOWEL** "

अब देखते हैं कि एक या एक से अधिक स्वर के तुरंत बाद हम एक व्यंजन कैसे पा सकते हैं:

regexpr("[^aeiou][aeiou]+",teststring)
#[1] 3
#attr(,"match.length")
#[1] 2
#attr(,"useBytes")
#[1] TRUE

हमारे पास लंबाई 2 के स्ट्रिंग 3 की स्थिति 3 पर एक मैच है, अर्थात: ju

अब अगर हम सभी मैच करवाना चाहते हैं:

gregexpr("[^aeiou][aeiou]+",teststring)
#[[1]]
#[1]  3  5 19
#attr(,"match.length")
#[1] 2 2 2
#attr(,"useBytes")
#[1] TRUE

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

आइए हमारे मैचों को एक चर में सहेजें और फिर उन्हें मूल स्ट्रिंग से निकालें:

matches <- gregexpr("[^aeiou][aeiou]+",teststring)
regmatches(teststring,matches)
#[[1]]
#[1] "ju" "wa" "yo"

यह शॉर्टकट नहीं करने के लिए अजीब लग सकता है, लेकिन यह हमारे पहले एक के मेल से दूसरे तार से निष्कर्षण की अनुमति देता है (दो लंबे वेक्टर की तुलना करें जहां आपको पता है कि पहले के लिए एक सामान्य पैटर्न है, लेकिन दूसरे के लिए नहीं, यह एक उत्कृष्ट अनुमति देता है आसान तुलना):

teststring2 <- "this is another string to match against"
regmatches(teststring2,matches)
#[[1]]
#[1] "is" " i" "ri"

ध्यान दें: डिफ़ॉल्ट रूप से पैटर्न पर्ल कम्पेटिबल रेगुलर एक्सप्रेशन नहीं है, लुकरॉइड जैसी कुछ चीजें समर्थित नहीं हैं, लेकिन यहां प्रस्तुत प्रत्येक फ़ंक्शन उन्हें सक्षम करने के लिए perl=TRUE तर्क के लिए अनुमति देता है।

बड़े डेटा सेट में मैच खोजें

बड़े डेटा सेट के मामले में, grepl("fox", test_sentences) की कॉल अच्छा प्रदर्शन नहीं करती है। बड़े डेटा सेट उदाहरण के लिए क्रॉल किए गए वेबसाइट या मिलियन ट्वीट्स आदि हैं।

पहला त्वरण perl = TRUE विकल्प का उपयोग है। इससे भी तेज विकल्प fixed = TRUE । एक पूर्ण उदाहरण होगा:

# example data
test_sentences <- c("The quick brown fox", "jumps over the lazy dog")

grepl("fox", test_sentences, perl = TRUE)
#[1]  TRUE FALSE

पाठ खनन के मामले में, अक्सर एक कॉर्पस का उपयोग किया जाता है। एक कॉर्पस को सीधे grepl साथ उपयोग नहीं किया जा सकता है। इसलिए, इस कार्य पर विचार करें:

searchCorpus <- function(corpus, pattern) {
  return(tm_index(corpus, FUN = function(x) {
    grepl(pattern, x, ignore.case = TRUE, perl = TRUE)
  }))
}