R Language
Mönstermatchning och utbyte

Introduktion

Syntax

• grep ("fråga", "ämne", option_args)

• grepl ("fråga", "ämne", option_args)

• gsub ("(grupp1) (grupp2)", "\\ grupp #", "ämne")

Anmärkningar

Göra ersättningar

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

Låt oss göra den runa räven röd:

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

Låt oss nu låta den "fast" räven agera "fastly" . Detta gör det inte:

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

sub bara den första tillgängliga ersättningen, vi behöver gsub för global ersättning :

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

Se Ändra strängar genom ersättning för fler exempel.

Hitta matchningar

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

Finns det en match?

grepl() används för att kontrollera om ett ord eller ett reguljärt uttryck finns i en sträng eller teckenvektor. Funktionen returnerar en TRUE / FALSE (eller "Boolean") vektor.

Lägg märke till att vi kan kontrollera varje sträng för ordet "räv" och få en boolesk vektor i gengäld.

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

Matcha platser

grep tar in en teckensträng och ett regelbundet uttryck. Det returnerar en numerisk vektor för index. Detta kommer att returnera vilken mening som innehåller ordet "räv" i den.

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

Matchade värden

Så här väljer du meningar som matchar ett mönster:

# 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"

detaljer

Eftersom "fox" -mönstret bara är ett ord, snarare än ett vanligt uttryck, kan vi förbättra prestanda (med antingen grep eller grepl ) genom att ange fixed = TRUE .

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

För att välja meningar som inte matchar ett mönster kan man använda grep med invert = TRUE ; eller följ underregleringsreglerna med -grep(...) eller !grepl(...) .

I både grepl(pattern, x) och grep(pattern, x) är x parametern vektoriserad , pattern är inte. Som ett resultat kan du inte använda dessa direkt för att matcha pattern[1] mot x[1] , pattern[2] mot x[2] och så vidare.

Sammanfattning av matcher

Efter att ha utfört t.ex. grepl kommandot, kanske du vill få en överblick över hur många matcher där TRUE eller FALSE . Detta är till exempel användbart i fall av stora datauppsättningar. För att göra det kör du 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)

Enkel och global match.

När du arbetar med vanliga uttryck är en modifierare för PCRE g för global matchning.

I R-matchning och ersättningsfunktioner har två versioner: första matchning och global matchning:

• sub(pattern,replacement,text) kommer att ersätta den första förekomsten av mönster genom att ersätta i text

• gsub(pattern,replacement,text) gör samma sak som sub men för varje förekomst av mönster

• regexpr(pattern,text) kommer att returnera matchningens placering för första instansen av mönster

• gregexpr(pattern,text) returnerar alla matchningar.

Några slumpmässiga data:

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

# teststring
#[1] "htjuwakqxzpgrsbncvyo"

Låt oss se hur detta fungerar om vi vill ersätta vokaler med något annat:

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** "

Låt oss nu se hur vi kan hitta en konsonant omedelbart följt av en eller flera vokaler:

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

Vi har en matchning på position 3 i strängen med längd 2, dvs: ju

Nu om vi vill få alla matcher:

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

Allt detta är riktigt bra, men detta ger bara använda matchningspositioner och det är inte så lätt att få det som matchas, och här kommer regmatches Det enda syftet är att extrahera strängen matchad från regexpr, men den har en annan syntax.

Låt oss spara våra matchningar i en variabel och sedan extrahera dem från originalsträngen:

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

Det kan låta konstigt att inte ha en genväg, men detta tillåter extraktion från en annan sträng med matchningarna i vår första (tänk att jämföra två långa vektor där du vet att det finns ett vanligt mönster för den första men inte för den andra, detta tillåter en enkel jämförelse):

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

Observera: som standard är mönstret inte Perl Compatible Regular Expression, vissa saker som lookarounds stöds inte, men varje funktion som presenteras här möjliggör perl=TRUE argument för att aktivera dem.

Hitta matchningar i stora datamängder

När det gäller stora grepl("fox", test_sentences) fungerar inte samtalet från grepl("fox", test_sentences) bra. Stora datauppsättningar är t.ex. genomsökta webbplatser eller miljoner tweets, etc.

Den första accelerationen är användningen av alternativet perl = TRUE . Ännu snabbare är alternativet fixed = TRUE . Ett komplett exempel skulle vara:

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

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

Vid textbrytning används ofta ett korpus. Ett korpus kan inte användas direkt med grepl . Tänk därför på den här funktionen:

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