텍스트 | JDW BLOG

[R] stringr 패키지를 사용한 정규표현식

Sat, 03 Oct 2020 00:00:00 +0000

이전 장에서 R에서 사용되는 정규표현식에 대해 알아보았었는데요. 오늘은 정규표현식을 텍스트 데이터를 처리할때 사용하는 패키지인 stringr 과 함께 사용하는 방법에 대해 알아보도록 하겠습니다.

stringr

stringr 패키지는 Rstudio의 Hadley Wickham이 개발한 패키지입니다. dplyr , ggplot2 등과 같이 데이터를 깔끔한(tidy) 방식으로 처리하는것을 지향하는 tidyverse 패키지군에 속해 있으며, 그 중 stringr 은 문자열 처리에 특화된 패키지입니다. ‘string’의 준말인 str_이 함수 머릿말에 항상 등장하는 것이 특징입니다.

stringr 패키지의 주요 기능을 아래와 같이 분류하였고 각 경우에 맞는 상황을 가정하여 알아보도록 하겠습니다.

1. 특정 패턴과 ‘일치’
2. 특정 패턴의 ‘카운팅’
3. 특정 패턴이 ‘포함’ 된 경우
4. 특정 패턴의 ‘위치’ 를 반환
5. 특정 패턴을 새로운 것으로 ‘바꾸는’ 경우
6. 특정 패턴을 기준으로 ‘나누는’ 경우

예제 문장

연습용으로 사용할 문장은 stringr 패키지에 내장되어 있는 sentence 데이터를 사용하겠습니다. sentence는 총 1000문장으로 구성되어 있는데, 문장 전체를 사용할 필요가 없으므로 10문장 정도만을 추려서 사용하도록 하겠습니다.

regex_sentences <- stringr::sentences[1:10] # 예제용 문장 생성

regex_sentences
#>  [1] "The birch canoe slid on the smooth planks." 
#>  [2] "Glue the sheet to the dark blue background."
#>  [3] "It's easy to tell the depth of a well."     
#>  [4] "These days a chicken leg is a rare dish."   
#>  [5] "Rice is often served in round bowls."       
#>  [6] "The juice of lemons makes fine punch."      
#>  [7] "The box was thrown beside the parked truck."
#>  [8] "The hogs were fed chopped corn and garbage."
#>  [9] "Four hours of steady work faced us."        
#> [10] "Large size in stockings is hard to sell."

일치

str_detect()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우를 찾을때 사용하며, 실행 결과로서 boolean(참, 거짓)을 반환합니다.

str_detect(regex_sentences, '[aeiou]') # 알파벳 모음 'a' or 'e' or 'i' or 'o' or 'u'가 있을 경우 TRUE
#>  [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

str_detect(regex_sentences, '[easy]')  # 알파벳 'e' or 'a' or 's' or 'y'가 있을 경우 TRUE 
#>  [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

str_detect(regex_sentences, '(easy)')  # 알파벳 'easy'가 있을 경우 TRUE 
#>  [1] FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE

str_extract()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우, 그것을 반환합니다.

str_extract(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 글자가 존재하면 그것을 반환 
#>  [1] "e" "u" "e" "e" "i" "e" "e" "e" "o" "a"

str_extract(regex_sentences, '[:punct:]') # 문장부호가 존재하면 그것을 반환 
#>  [1] "." "." "'" "." "." "." "." "." "." "."

함수는 조건에 일치하는 결과를 반환하였는데요. 자세히 보면 조건에 일치한 것이 여러개 있음에도 불구하고 오직 최초 값만을 반환하는 것을 볼 수 있습니다. 그렇다면 조건에 일치하는 모든 값을 찾고자 할 땐 어떻게 해야할까요? 바로 str_extract_all() 함수를 사용하면 됩니다. stringr 패키지 함수 중 몇몇의 함수는 함수 말미에 _all이 붙는 함수들이 있습니다. 이들 함수들은 조건에 맞는 모든 값을 반환하는 특징이 있습니다.

str_extract_all(regex_sentences, '[aeiou]')
#> [[1]]
#>  [1] "e" "i" "a" "o" "e" "i" "o" "e" "o" "o" "a"
#> 
#> [[2]]
#>  [1] "u" "e" "e" "e" "e" "o" "e" "a" "u" "e" "a" "o" "u"
#> 
#> [[3]]
#> [1] "e" "a" "o" "e" "e" "e" "o" "a" "e"
#> 
#> [[4]]
#>  [1] "e" "e" "a" "a" "i" "e" "e" "i" "a" "a" "e" "i"
#> 
#> [[5]]
#>  [1] "i" "e" "i" "o" "e" "e" "e" "i" "o" "u" "o"
#> 
#> [[6]]
#>  [1] "e" "u" "i" "e" "o" "e" "o" "a" "e" "i" "e" "u"
#> 
#> [[7]]
#>  [1] "e" "o" "a" "o" "e" "i" "e" "e" "a" "e" "u"
#> 
#> [[8]]
#>  [1] "e" "o" "e" "e" "e" "o" "e" "o" "a" "a" "a" "e"
#> 
#> [[9]]
#>  [1] "o" "u" "o" "u" "o" "e" "a" "o" "a" "e" "u"
#> 
#> [[10]]
#>  [1] "a" "e" "i" "e" "i" "o" "i" "i" "a" "o" "e"

str_extract_all(regex_sentences, '[:punct:]')
#> [[1]]
#> [1] "."
#> 
#> [[2]]
#> [1] "."
#> 
#> [[3]]
#> [1] "'" "."
#> 
#> [[4]]
#> [1] "."
#> 
#> [[5]]
#> [1] "."
#> 
#> [[6]]
#> [1] "."
#> 
#> [[7]]
#> [1] "."
#> 
#> [[8]]
#> [1] "."
#> 
#> [[9]]
#> [1] "."
#> 
#> [[10]]
#> [1] "."

str_extract_all() 함수의 결과, 조건에 부합하는 모든 값이 list 형으로 반환된 것을 볼 수 있습니다.

카운팅

str_count()함수는 특정 문자 혹은 패턴(정규표현식)과 일치하는 경우를 계산합니다.

str_count(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 문자의 개수를 반환 
#>  [1] 11 13  9 12 11 12 11 12 11 11

str_count(regex_sentences, '^(The)') # 시작이 'The'인 경우를 셈 
#>  [1] 1 0 0 1 0 1 1 1 0 0

포함

str_subset()함수는 특정 문자 혹은 패턴(정규표현식)이 포함된 경우를 반환합니다.

str_subset(regex_sentences, '[aeiou]') # 'a' or 'e' or 'i' or 'o' or 'u' 문자가 포함된 경우를 반환 
#>  [1] "The birch canoe slid on the smooth planks." 
#>  [2] "Glue the sheet to the dark blue background."
#>  [3] "It's easy to tell the depth of a well."     
#>  [4] "These days a chicken leg is a rare dish."   
#>  [5] "Rice is often served in round bowls."       
#>  [6] "The juice of lemons makes fine punch."      
#>  [7] "The box was thrown beside the parked truck."
#>  [8] "The hogs were fed chopped corn and garbage."
#>  [9] "Four hours of steady work faced us."        
#> [10] "Large size in stockings is hard to sell."

str_subset(regex_sentences, '^(The)')  # 시작이 'The'인 문장을 반환
#> [1] "The birch canoe slid on the smooth planks." 
#> [2] "These days a chicken leg is a rare dish."   
#> [3] "The juice of lemons makes fine punch."      
#> [4] "The box was thrown beside the parked truck."
#> [5] "The hogs were fed chopped corn and garbage."

str_subset(regex_sentences, 'p[:alpha:]{1,}\\.$') # 'p'뒤에 알파벳이 한번 이상 나오면서 마침표로 끝나는 경우 
#> [1] "The birch canoe slid on the smooth planks."
#> [2] "The juice of lemons makes fine punch."

위치

str_locate()함수는 특정 문자 혹은 패턴(정규표현식)에 맞는 경우의 시작 지점과 끝 지점을 반환합니다. R에 기본적으로 내장되어 있는 영어 소문자 데이터인 letters를 통해 알아보겠습니다.

letters
#>  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
#> [20] "t" "u" "v" "w" "x" "y" "z"

패턴의 위치를 찾기 위해선 하나로 묶인 데이터가 필요하므로 str_c() 함수를 사용하여 하나의 벡터로 묶었습니다. (str_c()함수는 __stringr__패키지의 문자를 결합하는 함수. R의 내장함수인 paste()와 동일하게 동작)

letters <- str_c(letters, collapse = '');

letters # 하나의 벡터값으로 변환 
#> [1] "abcdefghijklmnopqrstuvwxyz"

str_locate(letters, '[a-z]+') # 'a'부터 'z' 까지의 문자가 한개 이상 나오는 경우의 시작과 끝을 반환 
#>      start end
#> [1,]     1  26

str_locate(letters, '^[a][a-z]+[z]$') # 시작이 'a'이며, 바로 뒤에 'a' 부터 'z'까지의 문자 중 하나가 한번 이상 나오며, 끝이 'z'인 경우의 시작 지점과 끝 지점을 반환.
#>      start end
#> [1,]     1  26

str_locate(letters, '^[a-z][a-z]+$') # 시작이 'a' 부터 'z' 까지의 문자 중 하나이며, 끝이 'a' 부터 'z' 까지의 문자 중 하나인 경우의 시작 지점과 끝 지점.
#>      start end
#> [1,]     1  26

str_locate(letters, '(abcde)') # 'abcde'의 시작 지점과 끝 지점을 반환 
#>      start end
#> [1,]     1   5

str_locate(letters, '(xyz)') # 'xyz'의 시작 지점과 끝 지점을 반환  
#>      start end
#> [1,]    24  26

str_locate_all()함수를 통해 조건에 맞는 모든 값의 위치를 추출할 수 있습니다.

str_locate(letters, '[aeiou][^aeiou]+') # 'a' or 'e' or 'i' or 'o' or 'u'문자 뒤에 'a' or 'e' or 'i' or 'o' or 'u' 문자가 아닌 문자가 하나 이상 나오는 최초 경우의 시작 지점과 끝 지점을 반환 
#>      start end
#> [1,]     1   4

str_locate_all(letters, '[aeiou][^aeiou]+') # 'a' or 'e' or 'i' or 'o' or 'u'문자 뒤에 'a' or 'e' or 'i' or 'o' or 'u' 문자가 아닌 문자가 하나 이상 나오는 모든 경우의 시작 지점과 끝 지점을 반환 
#> [[1]]
#>      start end
#> [1,]     1   4
#> [2,]     5   8
#> [3,]     9  14
#> [4,]    15  20
#> [5,]    21  26

바꾸기

str_replace()는 특정 문자 혹은 패턴(정규표현식)에 맞는 경우를 새로운 문자로 바꾸는 함수입니다.

str_replace(regex_sentences, 'k', "'K'") # 최초로 매칭되는 문자 k를 'K'로 변환  
#>  [1] "The birch canoe slid on the smooth plan'K's." 
#>  [2] "Glue the sheet to the dar'K' blue background."
#>  [3] "It's easy to tell the depth of a well."       
#>  [4] "These days a chic'K'en leg is a rare dish."   
#>  [5] "Rice is often served in round bowls."         
#>  [6] "The juice of lemons ma'K'es fine punch."      
#>  [7] "The box was thrown beside the par'K'ed truck."
#>  [8] "The hogs were fed chopped corn and garbage."  
#>  [9] "Four hours of steady wor'K' faced us."        
#> [10] "Large size in stoc'K'ings is hard to sell."

str_replace(regex_sentences, '\\.', '\\?') # 최초로 매칭되는 마침표를 물음표로 변환 
#>  [1] "The birch canoe slid on the smooth planks?" 
#>  [2] "Glue the sheet to the dark blue background?"
#>  [3] "It's easy to tell the depth of a well?"     
#>  [4] "These days a chicken leg is a rare dish?"   
#>  [5] "Rice is often served in round bowls?"       
#>  [6] "The juice of lemons makes fine punch?"      
#>  [7] "The box was thrown beside the parked truck?"
#>  [8] "The hogs were fed chopped corn and garbage?"
#>  [9] "Four hours of steady work faced us?"        
#> [10] "Large size in stockings is hard to sell?"

마찬가지로 str_replace_all()함수를 통해 조건에 맞는 모든 값을 바꿀 수 있습니다.

str_replace(regex_sentences, '[:alpha:]{1,}', 'word') # 최초로 매칭되는 알파뱃이 한개 이상인 경우를 'word'로 변환 
#>  [1] "word birch canoe slid on the smooth planks." 
#>  [2] "word the sheet to the dark blue background." 
#>  [3] "word's easy to tell the depth of a well."    
#>  [4] "word days a chicken leg is a rare dish."     
#>  [5] "word is often served in round bowls."        
#>  [6] "word juice of lemons makes fine punch."      
#>  [7] "word box was thrown beside the parked truck."
#>  [8] "word hogs were fed chopped corn and garbage."
#>  [9] "word hours of steady work faced us."         
#> [10] "word size in stockings is hard to sell."

str_replace_all(regex_sentences, '[:alpha:]{1,}', 'word') # 알파뱃이 한개 이상인 모든 값을 'word'라는 단어로 변환 
#>  [1] "word word word word word word word word."          
#>  [2] "word word word word word word word word."          
#>  [3] "word'word word word word word word word word word."
#>  [4] "word word word word word word word word word."     
#>  [5] "word word word word word word word."               
#>  [6] "word word word word word word word."               
#>  [7] "word word word word word word word word."          
#>  [8] "word word word word word word word word."          
#>  [9] "word word word word word word word."               
#> [10] "word word word word word word word word."

str_replace(regex_sentences, '[:space:]', '') # 최초로 매칭되는 띄어쓰기를 공백으로 변환 
#>  [1] "Thebirch canoe slid on the smooth planks." 
#>  [2] "Gluethe sheet to the dark blue background."
#>  [3] "It'seasy to tell the depth of a well."     
#>  [4] "Thesedays a chicken leg is a rare dish."   
#>  [5] "Riceis often served in round bowls."       
#>  [6] "Thejuice of lemons makes fine punch."      
#>  [7] "Thebox was thrown beside the parked truck."
#>  [8] "Thehogs were fed chopped corn and garbage."
#>  [9] "Fourhours of steady work faced us."        
#> [10] "Largesize in stockings is hard to sell."

str_replace_all(regex_sentences, '[:space:]', '') # 매칭되는 모든 띄어쓰기를 공백으로 변환 
#>  [1] "Thebirchcanoeslidonthesmoothplanks." 
#>  [2] "Gluethesheettothedarkbluebackground."
#>  [3] "It'seasytotellthedepthofawell."      
#>  [4] "Thesedaysachickenlegisararedish."    
#>  [5] "Riceisoftenservedinroundbowls."      
#>  [6] "Thejuiceoflemonsmakesfinepunch."     
#>  [7] "Theboxwasthrownbesidetheparkedtruck."
#>  [8] "Thehogswerefedchoppedcornandgarbage."
#>  [9] "Fourhoursofsteadyworkfacedus."       
#> [10] "Largesizeinstockingsishardtosell."

나누기

str_split()는 특정 문자 혹은 패턴(정규표현식)을 기준으로 값을 나누는 함수입니다. 이때 기준이된 문자 혹은 패턴은 제거됩니다.

str_split(regex_sentences, '[:upper:]') # 대문자를 기준으로 분절 
#> [[1]]
#> [1] ""                                         
#> [2] "he birch canoe slid on the smooth planks."
#> 
#> [[2]]
#> [1] ""                                          
#> [2] "lue the sheet to the dark blue background."
#> 
#> [[3]]
#> [1] ""                                     
#> [2] "t's easy to tell the depth of a well."
#> 
#> [[4]]
#> [1] ""                                       
#> [2] "hese days a chicken leg is a rare dish."
#> 
#> [[5]]
#> [1] ""                                    "ice is often served in round bowls."
#> 
#> [[6]]
#> [1] ""                                    
#> [2] "he juice of lemons makes fine punch."
#> 
#> [[7]]
#> [1] ""                                          
#> [2] "he box was thrown beside the parked truck."
#> 
#> [[8]]
#> [1] ""                                          
#> [2] "he hogs were fed chopped corn and garbage."
#> 
#> [[9]]
#> [1] ""                                   "our hours of steady work faced us."
#> 
#> [[10]]
#> [1] ""                                       
#> [2] "arge size in stockings is hard to sell."

str_split(regex_sentences, '\\b') # 문자의 바운더리를 기준으로 분절 
#> [[1]]
#>  [1] ""       "The"    " "      "birch"  " "      "canoe"  " "      "slid"  
#>  [9] " "      "on"     " "      "the"    " "      "smooth" " "      "planks"
#> [17] "."     
#> 
#> [[2]]
#>  [1] ""           "Glue"       " "          "the"        " "         
#>  [6] "sheet"      " "          "to"         " "          "the"       
#> [11] " "          "dark"       " "          "blue"       " "         
#> [16] "background" "."         
#> 
#> [[3]]
#>  [1] ""      "It"    "'"     "s"     " "     "easy"  " "     "to"    " "    
#> [10] "tell"  " "     "the"   " "     "depth" " "     "of"    " "     "a"    
#> [19] " "     "well"  "."    
#> 
#> [[4]]
#>  [1] ""        "These"   " "       "days"    " "       "a"       " "      
#>  [8] "chicken" " "       "leg"     " "       "is"      " "       "a"      
#> [15] " "       "rare"    " "       "dish"    "."      
#> 
#> [[5]]
#>  [1] ""       "Rice"   " "      "is"     " "      "often"  " "      "served"
#>  [9] " "      "in"     " "      "round"  " "      "bowls"  "."     
#> 
#> [[6]]
#>  [1] ""       "The"    " "      "juice"  " "      "of"     " "      "lemons"
#>  [9] " "      "makes"  " "      "fine"   " "      "punch"  "."     
#> 
#> [[7]]
#>  [1] ""       "The"    " "      "box"    " "      "was"    " "      "thrown"
#>  [9] " "      "beside" " "      "the"    " "      "parked" " "      "truck" 
#> [17] "."     
#> 
#> [[8]]
#>  [1] ""        "The"     " "       "hogs"    " "       "were"    " "      
#>  [8] "fed"     " "       "chopped" " "       "corn"    " "       "and"    
#> [15] " "       "garbage" "."      
#> 
#> [[9]]
#>  [1] ""       "Four"   " "      "hours"  " "      "of"     " "      "steady"
#>  [9] " "      "work"   " "      "faced"  " "      "us"     "."     
#> 
#> [[10]]
#>  [1] ""          "Large"     " "         "size"      " "         "in"       
#>  [7] " "         "stockings" " "         "is"        " "         "hard"     
#> [13] " "         "to"        " "         "sell"      "."

str_split(regex_sentences, '\\s') # 띄어쓰기를 기준으로 분절 
#> [[1]]
#> [1] "The"     "birch"   "canoe"   "slid"    "on"      "the"     "smooth" 
#> [8] "planks."
#> 
#> [[2]]
#> [1] "Glue"        "the"         "sheet"       "to"          "the"        
#> [6] "dark"        "blue"        "background."
#> 
#> [[3]]
#> [1] "It's"  "easy"  "to"    "tell"  "the"   "depth" "of"    "a"     "well."
#> 
#> [[4]]
#> [1] "These"   "days"    "a"       "chicken" "leg"     "is"      "a"      
#> [8] "rare"    "dish."  
#> 
#> [[5]]
#> [1] "Rice"   "is"     "often"  "served" "in"     "round"  "bowls."
#> 
#> [[6]]
#> [1] "The"    "juice"  "of"     "lemons" "makes"  "fine"   "punch."
#> 
#> [[7]]
#> [1] "The"    "box"    "was"    "thrown" "beside" "the"    "parked" "truck."
#> 
#> [[8]]
#> [1] "The"      "hogs"     "were"     "fed"      "chopped"  "corn"     "and"     
#> [8] "garbage."
#> 
#> [[9]]
#> [1] "Four"   "hours"  "of"     "steady" "work"   "faced"  "us."   
#> 
#> [[10]]
#> [1] "Large"     "size"      "in"        "stockings" "is"        "hard"     
#> [7] "to"        "sell."

참고자료

[R] 정규표현식 활용한 텍스트 데이터 다루기

Fri, 02 Oct 2020 00:00:00 +0000

문자형 데이터를 다루는데는 수 많은 기법들이 있습니다. R에서 제공하는 기본 함수들을 통해 처리하기도 하고, 텍스트처리에 특화된 패키지함수를 사용하여 원하는 처리를 할 수 있는데요. 오늘은 그 중에 텍스트데이터를 다루는데 효과적으로 사용되는 정규표현식을 사용하는 법에 대해 알아보도록 하겠습니다.

정규표현식

정규표현식(regular expression)은 특정한 규칙을 가진 문자열의 집합을 표현하는데 사용하는 형식 언어입니다. 프로그래밍에서 조건문과 반복문을 통해 원하는 결과값을 도출해내는 것처럼, 텍스트데이터에서 조건과 패턴에 맞는 문자열을 찾거나 추출할때 정규식을 사용합니다. 정규표현식에는 특별한 의미를 지니고 있는 메타문자 와 문자 그대로의 의미를 지닌 일반문자 로 구성되어 있습니다.

메타문자

메타문자는 정규표현식에서 특별한 의미를 갖는 문자 기호입니다. 키보드에서 알파벳과 숫자를 제외한 특수 기호중에서 미리 정의한 기능을 가진 기호들을 메타문자라고 합니다. ! + \ & ^ [] ~ 등의 문자들이 메타 문자이며 이들은 각각 부여받은 기능들이 있어 이를 조합하여 특정한 패턴을 정의하는 방식으로 사용됩니다.

이해를 돕기위해 예시와 함께 살펴보도록 하겠습니다.

정규표현식 사용자 함수 생성

R Studio의 stringr 패키지 Cheat Sheet에 좋은 예시함수가 있어서 이를 차용하였습니다. 정규표현식 조건에 맞는 문자는 음영처리되어 보여집니다.

see <- function(rx) str_view_all("abc ABC 123\t.!?\\(){}\n abcde aaa bacad .a.aa.aaa abbaab ababcbabcdcbabcde", rx)

“^”

^(윗꺽쇠)는 문자열의 시작지점을 의미합니다.

see('^') # 문자열의 시작지점을 매칭

“$”

$(달러표시)는 문자열의 끝 또는 문서의 끝을 의미합니다.

see('$') # 문자열의 끝지점을 매칭

“.”

.(마침표)는 임의의 한 글자를 의미합니다.

see('.') # 임의의 글자를 매칭

다른 규칙없이 마침표만을 단독으로 사용하니 임의의 모든 글자가 선택되었습니다.

“?”

?(물음표)는 앞에 지정된 문자가 없거나 하나가 있음을 의미합니다.

see('?')

#> Error in stri_locate_all_regex(string, pattern, omit_no_match = TRUE, : Syntax error in regexp pattern. (U_REGEX_RULE_SYNTAX, context=`?`)

물음표를 단독으로 사용하니 에러가 발생하였습니다. 이는 물음표 조건에 맞지 않기 때문입니다. ‘ab?c’(a와 c 사이에 b가 하나 있거나 아니면 아예 없거나) 조건으로 설정해보겠습니다.

see('ab?c') # 'a'와 'c' 사이에 'b'가 하나 있거나 혹은 아예 없는 경우 ('abc' or 'ac')

정규표현식은 대소문자를 구분하기 때문에 소문자 ’abc’와 ’ac’가 선택된 것을 볼 수 있습니다. 정규표현식의 규칙은 매우 엄격하게 지켜지기 때문에 정규표현을 사용할 때는 정확한 규칙을 만들어서 사용할 필요가 있습니다.

“|”

|(또는)은 의미 그대로 또는을 의미합니다. | 기호를 기준으로 좌우에 해당하는 문자들을 찾습니다.

see('a|c') # 'a' 또는 'c'를 찾아냄

“+”

+(더하기)는 앞 문자가 1개이상인 경우를 의미합니다. + 기호의 좌측 문자를 기준으로 찾습니다.

see('a+')  # 'a' 글자가 한 개 이상 존재하는 경우

see('ac+') # 'a' 다음에 'c'가 하나 이상 있음

“*”

*(곱하기)는 앞 문자가 0개이상 인 경우를 의미합니다.

see('a*') # 'a' 글자를 반환

see('ac*')# 'a' 다음에 'c'가 없거나 하나 이상 있음

*** **(곱하기)는 +(더하기)와 유사하지만 결정적인 차이점으로 +(더하기)는 기호에 해당하는 문자가 하나라도 있는 문자를 반환하지만, *(곱하기)는 앞에 해당문자가 존재하지 않더라도 반환하는 특징이 있습니다.

“[ ]”

[ ](대괄호)는 문자를 묶어서 표현할때 사용됩니다. 대괄호에 묶인 문자들은 각각 or로 취급이 됩니다.

see('[abc]')        # 'a' or 'b' or 'c'를 찾아 반환

see('[abcde]c')     # 'c' 앞에 'a' or 'b' or 'c' or 'd' or 'e' 문자를 찾아 반환 ('ac', 'bc' 반환)

see('[A-Z][A-Z]C')  # 'C'의 두 부분 앞 문자에서 A부터 Z글자까지 있는 문자를 찾아서 반환 ('ABC' 반환)

또한, 특정한 문자를 제외하는 의미로서 대괄호 안에 ^(윗 꺽쇠)를 사용합니다.

see('[^abc]') # 'a' or 'b' or 'c'를 제외한 문자를 반환

“{ }”

{ }(중괄호)는 문자의 개수를 샐때 사용됩니다. 중괄호에는 세가지 용법이 있습니다.

{n,m} : 앞 문자가 n개 이상 m개 이하를 의미.
{n,} : 앞 문자가 n개 이상을 의미.
{n} : 앞 문자가 정확하게 n개를 의미.

see('a{1,2}') # 'a' 글자가 1개 이상 2개 이하를 표시

see('b{1,}')  # 'b' 글자가 1개 이상인 경우를 표시

see('c{1}')   # 'c' 글자가 1개인 경우를 표시

“( )”

( )(소괄호)는 문자를 묶어서 표현할때 사용합니다. 소괄호에 묶인 문자들은 각각 and로 취급됩니다.

see('(abc)')    # 'abc' 문자를 찾아 반화

see('(abcde)c') # 'c' 앞에 'abcde' 문자를 찾아 반환 (조건에 맞는 결과 없음)

see('a(bc)ba')  # 'a' 와 'ba' 사이에 'bc'가 존재하는 경우의 문자를 반환 ('abcba' 반환)

see('a(b|c)ba') # 'a' 와 'ba' 사이에 'b' 또는 'c'가 존재하는 경우의 문자를 반환 ('abba' 반환 )

대괄호에 묶인 문자는 ‘or’ 취급이지만, 소괄호는 위의 경우처럼 별도의 or 표시 없이는 ‘and’ 취급이 되는것이 차이점입니다.

“\”

앞서 .(마침표)는 임의의 한 글자를 찾을때 사용하는 메타문자라고 말씀을 드렸는데요. 그렇다면 만약 정규표현식을 사용하여 마침표 자체를 찾고싶을땐 어떻게 해야할까요? ’a.a’라는 문자를 찾는 상황을 가정해보겠습니다.

see('a.a') # 'a.a' 문자 반환?

‘a.a’라는 문자를 찾은걸 볼 수 있지만, 그것과 더불어서 ’aaa,’ ‘aca,’ ’a a’문자 역시 매칭이 되는 것을 볼 수 있습니다. 그 이유는 공교롭게도 “.”(마침표)역시 정규표현식에서 특수한 의미를 갖는 메타문자이기 때문입니다. 정규표현식 내에서 메타문자 자체를 특정하기 위해선 그 문자 앞에 메타문자 종류중 하나인 “\”(역슬래시)를 붙여야합니다.

그렇다면 이번에는 역슬래시를 활용하여 ’a.a’라는 문자를 찾아보도록 하겠습니다. 문자 가운데에 마침표가 메타문자가 아니라는것을 인지시키기 위하여 마침표 앞에 역슬래시를 붙였습니다.

see('a\.a') # 역슬래시 사용

#> Error: "'a\."로 시작하는 문자열 중에서 '\.'는 인식할 수 없는 이스케이프입니다

역슬래시를 사용했음에도 불구하고 에러가 발생하였습니다. 여기서 한가지 더 짚고 넘어가야 할 부분은 메타문자를 찾기 위해선 역슬래시를 두 개를 붙여야 한다는 것입니다. 왜 그러하냐 하면 입력된 문자를 R parser가 처리하는 과정에서 역슬래시를 추정하는데 두 개의 역슬래시를 요구하기 때문입니다. 역슬래시를 하나만을 붙여서는 R에서 인지하지 못합니다. 역슬래시의 기능을 사용하기 위해선 역슬래시 두 개를 붙여줘야 합니다. 그래야 비로소 R이 두 개 붙인 역슬래시 앞의 역슬래시가 일반문자가 아님을 인지하고 해당 패턴을 찾아냅니다.

이처럼 역슬래시가 메타문자를 메타문자로부터 탈출시키기에 이스케이프 문자라 부르기도 합니다.

see('a\\.a') # 역슬래시 두 개 사용

이번에는 찾고자 하던 ’a.a’단어를 정확하게 찾아낸 것을 볼 수 있습니다.

“\ + 일반문자”

앞서 역슬래시( \ )가 일반문자로 탈출시키는 이스케이프 문자라 설명드렸는데요. 정규표현식에서는 이러한 이스케이프 문자의 특성을 살린 특별한 기능이 몇 가지 더 있습니다. 그건 바로 일반 이스케이프 문자와 일반문자와의 조합을 통해 새로운 기능을 수행하는 것입니다. 일반문자중 일부 문자들은 이러한 특성을 지니고 있으며, 이를 정리하자면 다음과 같습니다.

＼ + 일반문자	의미	예시
＼n	줄바꿈	see(“\\n”)
＼t	탭	see(“\\t”)
＼s	공백	see(“\\s”)
＼S	공백아님	see(“\\S”)
＼d	숫자	see(“\\d”)
＼D	숫자아님	see(“\\D”)
＼w	문자	see(“\\w”)
＼W	문자아님	see(“\\W”)
＼b	단어경계	see(“\\b”)

특수표현

이 밖에도 정규표현식에서는 “[: :]” 형태로 존재하는 특수한 표현식이 존재합니다.

［: :］	의미	예시
［:digit:］	숫자	see(“［:digit:］”)
［:alpha:］	문자	see(“［:alpha:］”)
［:lower:］	소문자	see(“［:lower:］”)
［:upper:］	대문자	see(“［:upper:］”)
［:alnum:］	문자+숫자	see(“［:alnum:］”)
［:punct:］	기호	see(“［:punct:］”)
［:graph:］	문자+숫자+기호	see(“［:graph:］”)
［:space:］	띄어쓰기	see(“［:space:］”)
［:blank:］	띄어쓰기+탭	see(“［:blank:］”)

참고로 위의 표에서 사용된 일부 역슬래시와 대괄호는 출력상의 이유로 인해 일반적으로 사용하는 문자가 아닌 특수문자로 대체하였습니다. 예시함수를 사용 할 때 혹시나 에러가 발생한다면 역슬래시와 대괄호를 원래 키로 수정하여 사용하시기 바랍니다.

위치 탐색자

다음은 문자를 기준으로 바로 앞뒤 문자를 찾거나 그 반대인 상황을 찾을때 사용하는 표현식입니다.

see('a(?=c)')  # 'a'가 'c' 바로 뒤에 있는 경우를 반환

see('a(?!c)')  # 'a'가 'c' 바로 뒤따르지 않는 경우를 반환

see('(?<=b)a') # 'a'가 'b' 바로 앞에 있는 경우를 반환

see('(?<!b)a') # 'a'가 'b' 바로 앞에 있지 않는 경우를 반환

정리를 하다보니 분량이 꽤나 길어진 것 같습니다. 정규표현식은 비단 R에서 뿐만 아니라 다른 프로그래밍 언어에서도 적극 사용되는 용법이어서 한번 익혀두면 두고두고 써먹을 수 있는 장점이 있는데요. 여기에 소개하지 못한 다른 정규표현식도 많이 존재합니다. 더 자세히 공부를 하고자 하시는 분들을 위한 링크를 밑에 삽입하였으니 참고하시면 도움이 될 수 있겠습니다. R에서 텍스트데이터를 다루는 패키지 중 하나인 stringr 패키지와 정규표현식을 결합하여 사용하면 더욱 효과적으로 사용할 수 있는데요. 이는 다음장에서 다뤄보도록 하겠습니다.

https://regexone.com/