728x90
반응형

이전 포스트까지 정규 표현식이 무엇인지, Python에서 정규 표현식을 어떻게 탐색하는지에 대해 알아보았다. 이번 포스트에서는 가장 중요한 "메타 문자로 정규 표현식 패턴 만들기"에 대해 알아보도록 하겠다.

 

 

 

1. 메타 문자로 정규 표현식 패턴 만들기

  • 메타 문자로 정규 표현식 만들기는 크게 3가지 방법으로 돌아간다.
  1. 패턴 문자열 생성: 찾고자 하는 패턴 문자열(문자 클래스)을 생성한다.
  2. 패턴 문자의 반복 지정: 패턴 문자열이 몇 번 반복되는지 지정하기
  3. 패턴 문자의 위치 지정: 패턴 문자열로 시작하거나 패턴 문자열로 끝나는지 지정한다.
  • 위 3개 과정은 다 함께 진행될 수도 있고, 하나만 진행될 수도 있다. 이 외에도 문자의 패턴들을 그룹으로 만들거나 |(or)를 이용하여, 원하는 패턴이 존재하는 경우를 선택하게 할 수도 있다.
  • 각 부분에 해당하는 메타 문자는 이전 포스트인 <Python-기초:3.0. 정규 표현식(1) - 소개: 정규 표현식과 메타 문자>를 보면 깔끔하게 표로 정리해놨으니, 이를 참고하기 바란다.

 

 

 

 

2. 패턴 문자열 생성 하기

2.1. 문자 클래스 [ ]

  • 문자 클래스(character class)라고 하며, [ ] 안에는 1개 이상의 문자를 넣을 수 있고, 그 문자 중 하나라도 일치한다면 일치하는 패턴으로 판단한다.
# [abc]라는 정규 표현식 패턴 생성
>>> pattern = "[abc]"
>>> regex_pattern = re.compile(pattern)

>>> Text_cat = "cat"
>>> print(regex_pattern.findall(Text_cat))
<re.Match object; span=(0, 1), match='c'>


>>> print(regex_pattern.findall(Text_cat))
['c', 'a']
  • "[abc]"는 3개의 문자가 들어 있는 것으로 보이지만, [ ]는 문자 하나로 인식한다.
  • cat은 "[abc]" 내부의 c와 일치하므로, match 되는 값인 'c'를 반환하였다.
  • findall() 메서드로 탐색 시, 일치하는 패턴인 ["c", "a"]를 하나하나 반환하였다.

 

 

2.2. 문자 클래스 [ ]와 범위 특수 문자 "-"

  • [ ] 안에 들어간 특수문자는 메타 문자가 아닌 원본 문자의 의미로 사용된다.
  • 그러나, "-"와 "^"는 별개의 의미를 갖는다.
  • "-"는 문자 클래스 내에서 범위를 의미한다.
>>> pattern = "[0-9]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['1', '0']
  • "[0-9]"는 0에서 9까지의 숫자를 의미한다.
>>> pattern = "[a-z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['h', 'a', 'v', 'e', 'a', 't', 's']
  • "[a-z]"는 a부터 z까지의 영문자, 즉 소문자를 의미한다.
>>> pattern = "[A-Z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['I', 'C']
  • [A-Z]는 A부터 Z까지의 영문자, 즉 대문자를 의미한다.
>>> pattern = "[a-z]"
>>> regex_pattern = re.compile(pattern, re.IGNORECASE)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
  • re.compile() 안에 re.IGNORECASE(re.I)를 넣으면 대소문자 구분 없이 사용할 수 있다.
>>> pattern = "[a-zA-Z0-9]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['H', 'o', 'r', 'm', 'e', 'l', 'F', 'o', 'o', 'd', 's', '1', '0']
  • "[a-z]", "[A-Z]", "[0-9]"는 한 문자 클래스 안에서 동시에 사용될 수 있다.
>>> pattern = "[가-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['나', '는', '미', '국', '의', '의', '스', '팸', '통', '조', '림', '개', '를', '가', '지', '고', '있', '다']
  • "[가-힣]"을 쓰면 한글에 대해서도 정규 표현식을 사용할 수 있다.
>>> pattern = "[가\-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다. - 힣힣"
>>> print(regex_pattern.findall(Text_data))
['가', '-', '힣', '힣']
  • "\-"처럼 특수 문자 앞에 역슬래시를 사용하면 본래 문자를 그대로 쓸 수 있다.

 

 

2.3. 문자 클래스 [ ]와 반대 특수 문자 "^"

  • 문자 클래스 [ ] 안에 "^"가 들어가면, 그 내용이 반대가 된다.
>>> pattern = "[^가-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', 'H', 'o', 'r', 'm', 'e', 'l', ' ', 'F', 'o', 'o', 'd', 's', ' ', ' ', ' ', '1', '0', ' ', ' ', '.']
  • 한글을 제외한 모든 문자열이 반환된 것을 볼 수 있다.
  • 공백(" ")도 하나의 문자이며, 이는 문자 클래스 안에 띄어쓰기로 표현할 수 있다.
>>> pattern = "[^가-힣 ]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['H', 'o', 'r', 'm', 'e', 'l', 'F', 'o', 'o', 'd', 's', '1', '0', '.']
>>> pattern = "[\^a-z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['o', 'r', 'm', 'e', 'l', 'o', 'o', 'd', 's']
  • "-"와 마찬가지로 앞에 역슬래시를 붙여 "\^"로 만들면 문자열 자체로 사용할 수 있다.

 

 

2.4. 별도 표기법을 가진 문자 클래스

  • 앞서 학습한 문자 클래스 중 "[a-z]", "[A-Z]", "[0-9]", "[ ]"는 꽤나 빈번하게 사용되는 문자 클래스기 때문에 이를 별도의 표기법으로도 제공한다.
  • 대표적인 문자 클래스는 6가지로 다음과 같다.
문자 클래스 기능 유사한 기능을 하는 문자 클래스
\d 숫자 [0-9]
\D 숫자가 아닌 것 [^0-9]
\s 공백 문자(공백은 단순 띄어쓰기부터 내려쓰기, 탭 등을 포함) [ \t\n\r\f\v]
\S 공백 문자가 아닌 것 [^ \t\n\r\f\v]
\w 문자 + 숫자 + 언더바("_") [a-zA-Z0-9_]
\W 문자 + 숫자 + 언더바("_")가 아닌 것 [^a-zA-Z0-9_]
>>> pattern = "\W"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '.']
  • 위에서 소개한 별도 표기법을 가진 문자 클래스는 [ ] 안에 담을 수도, 따로 사용할 수도 있다.
>>> pattern = "\d"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['1', '0']


>>> pattern = "[\d]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['1', '0']
  • 한 문자 클래스에 대해선 별 의미가 없으나, 두 문자 클래스를 동시에 사용할 땐 크게 다르다.
>>> pattern = "\s\d"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' 1']
  • "\s\d"는 공백 뒤에 숫자가 오는 패턴이므로 '통조림 10개를'에서 ' 1'에 매치된다.
>>> pattern = "[\s\d]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', ' ', ' ', ' ', ' ', '1', '0', ' ', ' ']
  • "[\s\d]"는 공백과 숫자를 함께 넣은 문자 클래스 "[ 0-9]"와 같으므로, 다른 결과를 반환한다.

 

 

2.5. 모든 문자를 의미하는 Dot "."

  • "."은 모든 문자열 한자리를 의미한다.
  • 단 "." 은 줄 바꿈 문자 "\n"는 제외한다.
>>> pattern = "\d."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10']
  • 숫자 뒤에 문자가 하나 오는 경우인 10을 가지고 왔다.
>>> pattern = ".\d."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' 10']
  • 공백도 Dot에 해당하므로 ' 10'을 가지고 왔다.
>>> pattern = "\d..."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10개를']
  • 추천하는 방법은 아니지만 Dot를 여러 개 붙여서 문자열의 길이도 지정할 수 있다.
  • Dot(".")은 기본적으로 줄 바꿈 문자인 "\n"을 제외하지만, re.DOTALL(re.S) 파라미터를 추가함으로써 줄 바꿈 문자도 포함할 수 있다.
>>> pattern = "\d..."
>>> regex_pattern = re.compile(pattern, re.DOTALL)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개\n 20개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10개\n', '20개를']

 

 

 

 

3. 패턴 문자열의 반복 지정

  • 앞서 패턴 문자열을 만드는 법을 배워봤다. 문자 클래스(Character class)는 기본적으로 한 자리이므로, 사용자가 원하는 패턴을 찾아내려면 패턴 문자열의 반복 수를 지정해주면 된다.
  • 반복 수를 지정하는 방법은 다음과 같다.
메타 문자 의미
+ 앞의 패턴 문자열이 1번 이상 반복되어야 한다.
* 앞의 패턴 문자열이 0번 이상 반복되어야 한다.
? 앞의 패턴 문자열은 존재할 수도 있고, 없을 수도 있다(0 이상 1 이하).
{n, m} 앞의 패턴 문자열은 n번 이상 m번 이하 반복되어야 한다.
{n, } 앞의 패턴 문자열은 n번 이상 반복되어야 한다.
{n} 앞의 패턴 문자열을 n번 반복되어야 한다.
  • 앞서 학습한 패턴 문자열 작성 방식과 위의 반복 수를 이용해서 문장 내 원하는 패턴을 찾아보도록 사자.
  • 다음과 같은 문장이 있다고 가정해보자.
>>> Sentence = "마동석씨의 핸드폰 번호는 010-1234-5678, 이메일 주소는 Email_ID.1234@naver.com이다."
  • 여기서 핸드폰 번호를 추출해보자.
  • 핸드폰 번호는 01[016789]-[0-9]{4}-[0-9]{4}의 패턴을 갖는다.
>>> pattern = "01[016789]-[0-9]{4}-[0-9]{4}"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['010-1234-5678']
  • 아주 쉽게 원하는 패턴을 찾아내었다.
  • 이번에는 이메일 주소를 추출해보자.
  • 이메일 주소의 패턴은 [a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]? 이다.
>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]?"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['Email_ID.1234@naver.com']
  • 이메일 주소의 패턴에는 "?"가 들어갔는데, 이메일 주소의 도메인은 아래와 같이 존재하는 경우도 있기 때문이다.
>>> Sentence = "나문희씨의 이메일 주소는 Email_ID@company.co.kr이다."

>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]?"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['Email_ID@company.co.k']
  • 정규 표현식의 첫 포스트에서 제시한 아래 예제에서 휴대전화 번호, 집 전화번호, 이메일 주소 들을 따로 추출해보자.
data = [
    "010.1234.5678", "010-1234-5678", "02-1234-5678", "031-123-4567", "042.987.6543",
    "emailID01@naver.com", "emailID02@gmail.com", "Email.03@daum.net", "EM_example.01@gmail.com",
    "email_1234@company.co.kr"
]
>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]*[a-z]*"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(data))

  • re 모듈은 기본적으로 하나의 텍스트 데이터에 대해 동작하므로, for문을 이용해서 하나하나씩 비교하고, 해당하는 list에 담아보도록 하자.
# Data가 담길 기본 list를 생성한다.
cellphone_list = []
homephone_list = []
email_list = []


# 각 카테고리별 패턴
cellPhone_pattern = re.compile("01[016789][\-.][0-9]{4}[\-.][0-9]{4}")
homePhone_pattern = re.compile("0[2-6][1-5]?[\-.][0-9]{3,4}[\-.][0-9]{4}")
email_pattern = re.compile("[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]*[a-z]*")


for target in data:
    
    cellPhone_Object = cellPhone_pattern.match(target)
    homePhone_Object = homePhone_pattern.match(target)
    email_Object = email_pattern.match(target)
    
    if cellPhone_Object != None:
        
        cellphone_list.append(cellPhone_Object.group())
        
    if homePhone_Object != None:
        
        homephone_list.append(homePhone_Object.group())
        
    if email_Object != None:
        
        email_list.append(email_Object.group())
>>> print(f"휴대전화 번호: {cellphone_list}")
>>> print(f"휴대전화 번호: {homephone_list}")
>>> print(f"휴대전화 번호: {email_list}")
휴대전화 번호: ['010.1234.5678', '010-1234-5678']
휴대전화 번호: ['02-1234-5678', '031-123-4567', '042.987.6543']
휴대전화 번호: ['emailID01@naver.com', 'emailID02@gmail.com', 'Email.03@daum.net', 'EM_example.01@gmail.com', 'email_1234@company.co.kr']
  • 앞서 학습한 패턴 문자열 생성과 패턴 문자열의 반복 횟수만 지정해주니 아주 간단하게 원하는 패턴만 추출하는 데 성공하였다.

 

 

 

 

4. 패턴 문자열의 위치 지정

  • 패턴 문자열이 맨 뒤에 있는지, 맨 앞에 있는지만을 지정할 수 있다.
  • '^': 패턴 문자열 앞에 위치하며, 텍스트의 맨 왼쪽이 해당 패턴 문자열로 시작해야 한다.
  • '$': 패턴 문자열 뒤에 위치하며, 텍스트의 맨 오른쪽이 해당 패턴 문자열로 끝나야 한다.
  • 아래와 같은 이름 데이터가 있다고 가정해보자.
>>> name = "김영수, 김나연, 최영호, 김영식, 박순자, 최정훈, 박성훈, 김상훈, 최현정, 박성민"

>>> name_pattern = re.compile("^김..")
>>> print(name_pattern.findall(name))
['김영수']


>>> name_pattern = re.compile("^최..")
>>> name_pattern.findall(name)
[]


>>> name_pattern = re.compile("박..$")
>>> name_pattern.findall(name)
['박성민']


>>> name_pattern = re.compile("김..$")
>>> name_pattern.findall(name)
[]
  • '^', '$' 패턴은 문자열의 맨 처음과 맨 끝만 중요하게 판단한다.
  • 성이 김으로 시작하는 사람을 찾고 싶다면, 물론 간단한 패턴 문자열 생성으로 해결할 수야 있다.
>>> name_pattern = re.compile("[ ]?김..")
>>> name_pattern.findall(name)
['김영수', ' 김나연', ' 김영식', ' 김상훈']
  • 그러나 간단한 몇 개의 조작만 한다면, '^', '$' 메타 문자만을 이용해서도 찾을 수 있다.
  • 먼저 각 이름의 구분자인 ', '를 줄 바꿈 문자인 '\n'으로 바꿔주자.
>>> name_LF = re.sub(", ", "\n", name)
>>> name_LF
'김영수\n김나연\n최영호\n김영식\n박순자\n최정훈\n박성훈\n김상훈\n최현정\n박성민'
  • re.sub(pattern, repl, string): string에서 pattern에 해당하는 문자열을 repl 문자열로 치환한다.
  • re.compile에 추가 파라미터 re.MULTILINE(re.M)를 하나 넣어줘 보자.
>>> name_pattern = re.compile("^김..", re.MULTILINE)
>>> name_pattern.findall(name_LF)
['김영수', '김나연', '김영식', '김상훈']
  • re.MULTILINE은 문자열 전체의 처음이나 끝이 아닌 각 라인의 처음이나 끝으로 설정해주는 파라미터이다.
  • 즉, '^'와 '$'를 각 줄에 적용할 수 있다는 것이다.
  • 이름이 "훈"으로 끝나는 사람도 쉽게 찾을 수 있다.
>>> name_pattern = re.compile("..훈$", re.MULTILINE)
>>> name_pattern.findall(name_LF)
['최정훈', '박성훈', '김상훈']
  • 이 외에도 "\A", "\Z"가 존재하는데, 각각 "^", "$"와 동일한 기능을 갖는다. 유일한 차이라면, re.MULTILINE 파라미터가 있어도 전체에 대해서 작동한다는 것이다.

 

 

 

 

5. 기타 메타 문자

  • 앞서 소개한 메타 문자 중 "|"와 "()" 이 두 가지를 아직 다루지 않았는데, "|"만 다루고, "()"는 다음 포스팅에서 다루도록 하겠다.
  • "()"는 Grouping이라는 것으로, 꽤나 복잡한 녀석이라 다음 포스트에서 자세히 설명해보도록 하겠다. 이번 포스트에선 "|"까지만 다루겠다.

 

5.1. "|": 또는(Or)

  • "A|B" 패턴 문자열이 있다면, A에 해당하는 패턴 문자열이나 B에 해당하는 패턴 문자열에 대해 가지고 온다.
>>> Text_data = "Banana, Apple, WaterMelon, Melon, StrawBerry"

>>> pattern = "Apple|Banana"
>>> regex_pattern = re.compile(pattern)
>>> print(regex_pattern.findall(Text_data))
['Banana', 'Apple']

 

 

 

지금까지 기본적인 정규 표현식 문법 작성 방법에 대해 알아보았다. 지금까지 다룬 내용만으로도 정규 표현식을 사용하는 것은 크게 어렵지 않으나, 혹시나 정규 표현식에 대해 보다 자세히 학습해보고 싶은 사람이 있을 수도 있으므로, 다음 포스트에서는 정규 표현식에 대한 보다 어려운 부분도 다뤄보도록 하겠다.

728x90
반응형
728x90
반응형

이전 포스트에서 정규 표현식이 무엇인지, 메타 문자가 무엇인지에 대해 가볍게 알아보았다. 앞서 학습한 메타 문자를 예제를 기반으로 제대로 다뤄보려면, 자신이 만든 정규 표현식 패턴이 제대로 만들어졌는지를 확인할 필요가 있다.

이번 포스트에서는 Python에서 정규 표현식을 어떻게 지원하는지 re 모듈을 통해 알아보도록 하겠다. 이번 포스트에서 예제로 정규 표현식으로 만든 패턴을 일부 사용하긴 할 것이나, 이는 다음 포스트에서 자세히 다룰 것이므로 이번에는 참고만 하도록 하자.

 

 

 

 

1. Python과 re 모듈

정규 표현식으로 만든 패턴 문자열이 제대로 작동하는지 알기 위해선 Python에서 기본적으로 제공하는 re 모듈에 대해 알 필요가 있다. 

  • re 모듈은 Python에서 정규 표현식을 지원하기 위해 제공하는 기본 라이브러리이다.
  • re 모듈은 컴파일러 객체를 선언하고, 다음과 같은 메서드를 통해 작동한다.
# re 모듈을 가지고 온다.
import re
pattern = "cat"

regex_pattern = re.compile(pattern)
  • re 모듈의 컴파일 객체는 다음과 같은 메서드를 통해 작동한다.
  • 컴파일 객체는 regex_pattern이 아닌 다른 변수명에 담아도 상관없다.
Method/Attribute 기능
match() 문자열의 왼쪽(시작)부터 컴파일된 정규 표현식 패턴 객체가 일치하는지 판단한다.
search() 문자열 전체에서 정규 표현식 패턴 객체와 일치하는 첫 문자의 위치를 찾는다.
findall() 정규 표현식 패턴 객체와 일치하는 모든 문자열을 찾아 리스트로 반환한다.
finditer() 정규 표현식 패턴 객체와 일치하는 모든 문자열을 찾아 이터레이터(Iterator)로 반환한다.

 

 

 

 

1.1. match()

  • match 함수는 왼쪽(시작)부터 정규 표현식 패턴이 일치하는 곳까지를 반환해준다.
  • 왼쪽부터라는 것이 무슨 뜻인지 아리송한 감이 있는데, 이게 정확히 어떻게 돌아가는지 알아보도록 하자.
  • 다음과 같은 정규 표현식 패턴과 Text_data가 있다고 가정해보자.
>>> pattern = "cats"

>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I love cats and I wish I had cats."
  • Text_data에는 pattern인 cats가 들어 있으므로, 문제없이 찾을 수 있을 것 같다.
  • 이를 match 메서드를 이용해서 탐색해보자.
>>> m = regex_pattern.match(Text_data)
>>> print(m)
None
  • 분명히 "cats"이라는 단어가 Text_data 안에 있음에도 탐색되지 않았다.
  • 이는 match() 메서드가 왼쪽에서부터 탐색하기 때문으로, 주어진 "cats"라는 pattern은 Text_data의 문장 중간에 존재하지, 앞에서부터는 존재하지 않기 때문이다.
  • "cats"가 나오도록 패턴을 조금 수정해보자.
    • 새로운 패턴은 다음 포스트에서 자세히 다룰 것이므로, 일단 따라가 보자!
>>> pattern = ".*cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(0, 33), match='I love cats and I wish I had cats'>
  • pattern으로 '.*cats'를 사용하였는데, '.*'는 cats 앞에 문자가 0개 이상 존재한다는 의미다.
  • 즉, 0개 이상 문자가 앞에 존재하는 cats와 일치하는 문장을 탐색한 것이다.
  • match 메서드는 _sre.SRE_Match 객체를 리턴한다.
  • _sre.SRE_Match 객체는 Match 된 문자열의 위치, Match 된 문자열을 반환한다.
  • 이를 통해, Match 메서드 시작부터 패턴이 일치하는지 판단한다는 것을 알 수 있다.

 

 

  • 이번에는 pattern을 아주 조금만 수정해서 match() 메서드의 성질을 보다 자세히 보자.
>>> pattern = ".*cats "
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(0, 12), match='I love cats '>
  • 앞서 사용한 pattern 뒤에 스페이스(space)를 추가하자, "I love cats "까지만 출력되었다.
  • 즉, match 메서드는 전체 문장이 얼마나 길든 간에 처음부터 pattern과 일치되는 곳까지만 반환하는 것을 알 수 있다.

 

 

1.1.1. match 객체가 제공하는 메서드

  • 앞서 match는 _sre.SRE_Match 객체를 반환한다고 하였는데, 이는 다음과 같은 메서드를 이용해 내부 정보에 접근할 수 있다.
Method / Attribute 기능
group() 매치된 문자열 출력
start() 매치된 문자열의 시작 지점 출력
end() 매치된 문자열의 끝 지점 출력
span() 매치된 문자열의 시작 지점과 끝 지점을 튜플로 출력
  • 예제를 통해 보도록 하자.
>>> pattern = ".*cats "
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)

>>> print(m.group())
>>> print(m.start())
>>> print(m.end())
>>> print(m.span())
I love cats 
0
12
(0, 12)

 

 

 

 

1.2. search()

  • search 메서드는 문자열 전체에서 정규 표현식 패턴 객체와 일치하는 첫 문자의 위치를 반환한다.
  • 앞서 만든 예제에 그대로 적용해보도록 하자.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(7, 11), match='cats'>
  • search 메서드도 match 메서드와 동일하게 _sre.SRE_Match 객체를 반환한다.
  • search 메서드는 match 메서드와 달리 pattern이 처음부터 일치할 필요는 없으며, Text_data 내 가장 먼저 일치하는 문자열의 위치와 문자열을 반환한다.
  • 만약 존재하지 않는 문자열을 검색하면, match와 마찬가지로 None을 반환한다.
>>> pattern = "dogs"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m)
None
  • search() 메서드는 match() 메서드와 동일한 _sre.SRE_Match 객체를 반환하므로, match와 동일한 방법을 통해, 원하는 값을 출력할 수 있다.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m.group())
>>> print(m.start())
>>> print(m.end())
>>> print(m.span())
cats
7
11
(7, 11)

 

 

 

 

1.3. findall()

  • findall() 메서드는 가장 설명이 깔끔하면서, 유용한 기능을 제공하는 메서드다.
  • 말 그대로, 문장 안에 원하는 텍스트가 존재하면 그 텍스트를 리스트(List)로 모두 가지고 오는 기능으로, 이를 이용해서 해당 문장 안에 패턴에 일치하는 문자열이 몇 개 존재하는지도 쉽게 확인할 수 있다.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.findall(Text_data)
>>> print(m)
['cats', 'cats']
  • match, search와 달리 리스트를 바로 반환하므로, group, start, end, span과 같은 함수를 사용하지 않는다.

 

 

 

 

1.4. finditer()

  • finditer()는 findall()의 진화 버전이라고 할 수 있는 메서드로, Python 초보자라면 그 기능을 알기 쉽지 않다.
  • finditer()와 findall()의 차이는 결과를 이터레이터(Iterator)로 출력할 것인지 리스트(List)로 출력할 것인지로, List로 출력하면, 사용하기는 단순하나 단지 패턴에 일치하는 단어들을 List에 담아 출력하므로, 그 기능이 한정적이다.
  • 그러나 finditer()는 이터레이터를 통해 값을 반환하므로, 더 많은 정보를 담을 수 있고, 엄청나게 큰 Text_data가 대상일 때, 메모리 측면에서도 훨씬 유리하다.
  • 이터레이터에 대해서는 나중에 자세히 다룰 것이므로, 간단하게 내가 원할 때, 순서대로 값을 반환할 수 있는 녀석이라고 생각하면 된다.
  • 이터레이터는 모든 데이터를 메모리에 올려놓지 않기 때문에 findall()보다 용량을 덜 차지한다는 장점이 있다.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)
>>> print(m)
<callable_iterator object at 0x000001EB3D932358>
  • 출력된 결과가 앞서 봤던 match(), search(), findall()과 다르게 전혀 알아볼 수 없는 녀석이 나왔다.
  • Python의 이터레이터는 next() 또는 for와 같은 함수를 이용해야 값을 출력할 수 있다.
# 첫 번째 next
>>> next(m)
<_sre.SRE_Match object; span=(7, 11), match='cats'>

# 두 번째 next
>>> next(m)
<_sre.SRE_Match object; span=(29, 33), match='cats'>

# 세 번째 next
>>> next(m)

  • next()로 이터레이터 안에 있는 값을 꺼내자 _sre.SRE_Match 객체가 반환되는 것을 볼 수 있다.
  • 이터레이터 안에는 2개의 객체만 존재하므로, 마지막 객체 반환 시, StopIteration을 출력하는 것을 볼 수 있다.
  • 이번에는 for문으로 이터레이터 안의 객체를 꺼내보자.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)

>>> for i in m: 
>>>    print(i)
    
<_sre.SRE_Match object; span=(7, 11), match='cats'>
<_sre.SRE_Match object; span=(29, 33), match='cats'>
  • finditer() 메서드는 findall() 메서드와 달리 _sre.SRE_Match 객체를 반환하므로, 문장 내 패턴에 일치하는 대상들의 위치 정보도 쉽게 반환할 수 있다.
>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)

>>> for i in m:
>>>    print(i.span())

(7, 11)
(29, 33)

 

 

 

 

이번 포스트에서는 Python에서 기본적으로 제공하는 re 모듈에 대해 한 번 다뤄봤다. 텍스트 데이터를 다룰 때, re 모듈은 매우 유용하게 사용되므로 꼭 숙지하도록 하자.

다음 포스트에서는 메타 문자를 이용하여, 예제 데이터에 대한 정규 표현식 패턴을 만들어보고, re 모듈로 이를 검증해보도록 하자.

728x90
반응형
728x90
반응형

이전 포스트까지 문자열(String)을 다루는 기본적인 방법에 대해 알아보았다. 텍스트 데이터의 양이 적고, 패턴이 매우 단순하다면 앞서 다룬 방법만으로도 충분하겠지만, 이를 넘어서는 텍스트 데이터를 다룰 땐 앞서 다룬 방법만으로는 데이터를 다루기가 보다 곤란하다. 이때 등장하는 것이 문자열이 갖는 특정 규칙을 이용해 패턴을 표현하는 정규 표현식이다.

 

 

 

 

1. 정규 표현식(Regular Expression)이란?

위키피디아에선 정규 표현식을 다음과 같이 설명한다 <출처: 위키백과, 정규 표현식>.


정규 표현식은 특정 규칙을 가진 문자열의 집합을 표현하는 데 사용하는 형식 언어로, 정규 표현식은 많은 텍스트 편집기와 프로그래밍 언어에서 문자열의 검색과 치환을 위해 지원하고 있으며, 특히 펄과 Tcl은 언어 자체에 강력한 정규 표현식을 구현하고 있다.


이를 이해하기 쉽게 아~~~주 간단하게 표현하면 다음과 같다.

"대상 문자열이 가지고 있는 특정 패턴을 정규 표현식이라는 이름의 패턴 문자열을 이용해서 찾아내는 방법"

당신이 "연락처"라는 데이터를 수집했다고 가정해보자, 응답자들은 단순히 연락처를 적으라고 하였으므로, 휴대전화 번호, 집전화번호, 이메일 주소와 같은 다양한 종류의 연락처를 입력하였고, 당신의 보스는 당신에게 휴대전화 번호와 집전화번호, 이메일 주소를 각각 분리해서 가지고 오라고 지시를 하였다. 애초에 이를 따로 수집했으면 이런 귀찮은 일도 안 생기겠지만, 이미 저질러진 일을 어쩌겠는가!라는 상황에서 유용하게 사용할 수 있는 것이 정규 표현식이다.

정규표현식에 대한 이해를 돕기 위해 수집한 데이터의 예시를 눈으로 보도록 하자.

data = [
    "010.1234.5678", "010-1234-5678", "02-1234-5678", "031-123-4567", "042.987.6543",
    "emailID01@naver.com", "emailID02@gmail.com", "Email.03@daum.net", "EM_example.01@gmail.com",
    "email_1234@company.co.kr"
]

위 예제 데이터를 보면, 휴대전화 번호와 집전화번호, 이메일 주소마다 고유한 패턴을 가지고 있는 것을 볼 수 있다.

  • 다음 패턴은 위 데이터만 대상으로 놓고 분류한 것이다.
  • 휴대전화 번호는 010 특수 기호 '.', '-' 숫자 4자리 '.', '-' 숫자 4자리로 구성되어 있다.
  • 집전화번호는 0 뒤에 1~9의 숫자가 1개에서 2개가 오고 그 뒤에 특수 기호 '.', '-' 숫자 3 ~ 4 자리, '.', '-' 숫자 4자리로 구성되어 있다.
  • 이메일 주소는 ID와 Domain으로 나눠지며, 그 사이에는 '@'가 존재한다.
  • ID는 영문 대, 소문자와 숫자, 특수문자 '.', '_"로 이루어져 있으며, 맨 앞에는 특수문자가 들어갈 수 없다.
  • Domain은 소문자로만 이루어져 있으며, 특수문자 '.'를 기준으로 소문자가 1개에서 2개의 그룹으로 연결된다.

정규 표현식은 위 패턴을 하나의 문법으로 만들어 그 문법에 해당하는 대상을 찾거나 바꿀 수 있는 도구다. 즉, 휴대전화 번호만 찾고 싶다면 휴대전화 번호의 기본적인 패턴을 문법으로 만들고 그 문법에 해당하는 텍스트 데이터를 조회하여, 휴대전화 번호만 가지고 오게 할 수 있다.

 

※ 팁

한 가지 팁이라면, 데이터만 보고 정규 표현식을 사용하는 것보다. 해당 데이터의 생성 방식을 먼저 찾아보고 정규 표현식을 사용하는 것이 일반화 측면에서 더 좋다. 다음과 같은 정보는 잠깐만 인터넷 검색을 해보면 알 수 있는 정보이다.

  • 휴대전화 번호의 통신망 식별번호
    • 010, 011, 016, 017, 018, 019
  • 지역번호
    • 02, 031, 032, 033, 041, 042, 043, 044, 051, 052, 053, 054, 055, 061, 062, 063, 064

 

정규 표현식 문법은 각종 특수문자가 섞여 있고, 문법 작성 방식이 가독성과 거리가 꽤 멀기 때문에 지저분해 보인다는 단점이 있어, 많은 데이터 분석 입문자들이 기피하는 경향이 있다. 그러나, 텍스트 데이터를 다룰 때, 정규 표현식을 다룰 수 있고 없고의 차이는 매우 크므로, 조금 고통스럽더라도 함께 공부해보도록 하자(막상 공부해보면 보기보다 할만하다!).

 

 

 

 

2. 정규 표현식 문법과 메타 문자

  • Python으로 정규 표현식을 다루는 법을 알기 전에 먼저 정규 표현식 문법부터 알아보도록 하자.
  • 정규 표현식은 언어마다 문법이 조금씩 다르므로, 사용하려는 프로그램 언어에 맞는 정규 표현식 문법을 공부하는 것이 좋다.
  • 정규 표현식 사용 방법은 일반적으로 다음과 같은 순으로 진행된다.
  1. 정규 표현식 문법 작성
  2. 작성된 문법을 이용한 조작(탐색, 대체 등)

 

 

2.1. 메타 문자(Meta characters)

  • 평상시, 큰 의미 없이 사용했던 특수 문자들이 정규 표현식에서는 특정한 기능을 갖는데, 이를 메타 문자라고 한다.
  • 정규 표현식 문법은 이 메타 문자와 찾고자 하는 Text 데이터로 구성된다.
  • 이 특수 문자를 문자 그대로 사용하려면 앞에 '\'(역 슬래시)를 넣어줘야 한다.
  • 역 슬래시는 한국인이 사용하는 일반적인 키보드에서 ''로 표기되며, ''는 보이기에만 이렇지 실제로는 역 슬래시로 작용하므로, 이를 그냥 사용해도 문제없다.
  • 메타 문자는 크게 '문자의 패턴', '문자의 반복', '문자열의 위치', '기타 기능'으로 구성된다.
  • 대표적인 메타 문자는 다음과 같다.
문자의 패턴 문자의 반복
[] 문자 클래스 + 앞 문자 패턴이 1개 이상
. 임의의 한 문자 * 앞 문자 패턴이 0개 이상
\d 숫자 ? 앞 문자가 없거나 하나 있음
\D 숫자가 아닌 것 {n, m} 앞 문자 패턴이 n개 이상 m개 이하
\w 문자, 숫자, _ {n, } 앞 문자 패턴이 n개 이상
\W 문자, 숫자, _가 아닌 것 {n} 앞 문자 패턴이 n개
\s 공백 문자    
\S 공백 문자가 아닌 것    

 

 

문자열의 위치 기타 기능
^ 문자열의 시작 | 또는(or)
$ 문자열의 끝 () 문자열 패턴의 그룹화

 

 

이번 포스트에서는 정규 표현식이 무엇인지 알아보고, 정규 표현식에 사용되는 메타 문자가 무엇인지 알아보았다. 다음 포스트에서는 Python에서 정규 표현식의 기능을 어떻게 제공하는지 파악해보도록 하자.

728x90
반응형

+ Recent posts