정규표현식 사용

• 메타문자: $()*+.?[]\^{}|
  • 정규표현식에선 a는 문자 a와 매칭되지만 (는 (와 매칭되지 않는다. (가 메타 문자이기 때문이다.
  • 이 때 \백 슬래쉬를 쓰면 문자로 인식된다. \(
• 정규표현식: https://velog.io/@markyang92/regex-expregex

• 정말 메타문자를 쓰지 않았는지 주의하자

match

• re.match(패턴, 문자열, 플래그)는 문자열의 맨 앞 부터 시작해서 작성한 패턴이 일치하는지 확인한다.
  
  a로 시작하는 매칭되는 문자에 대한 정보를 출력한다.
  
  'b'로 시작하므로, 매칭이 안된다.

search

• re.search(패턴, 문자열, 플래그): match와 유사하지만, 처음부터 일치하지 않아도 괜찮다.
  

findall

• re.findall(패턴, 문자열, 플래그): 문자열 내 패턴에 맞는 케이스를 전부 v찾아서 리스트로 변환한다.정규식에 매칭되는 문자열을 return

finditer

• re.findall과 유사하지만, 패턴에 맞는 문자열의 iterator를 반환한다.
  

fullmatch

• fullmatch(패턴, 문자열, 플래그)는 문자열에 시작과 끝이 정확하게 패턴과 일치할 때 반환한다.
  • match()는 처음부터 패턴에 맞으면 반환하지만, 해당 함수는 시작과 끝이 정확하게 일치해야한다.

import re

print(re.fullmatch('a', 'a'))
print(re.fullmatch('a', 'aaa'))
print(re.fullmatch('a', 'ab'))
print(re.fullmatch('a', 'ba'))
print(re.fullmatch('a', 'baa'))


# <re.Match object; span=(0, 1), match='a'>
# None
# None
# None
# Noneimport re

split

• 문자열에서 패턴이 맞으면 이를 기점으로 리스트로 쪼갠다.
• 3번째 인자 (최대 split 수)를 지정 시, 문자열을 지정한 수 만큼 쪼개고 그 수가 도달하면 쪼개지 않는다.

import re

print(re.split('a', 'abaabca'))
print(re.split('a', 'abaabca', 2))


# ['', 'b', '', 'bc', '']
# ['', 'b', 'abca']

sub

• sub(패턴, 교체할 문자열, 문자열, 최대 교체 수, 플래그): sub는 문자열에 맞는 패턴을 2번째 인자(교체할 문자열)로 교체한다.
  split의 최대 split 수와 동일하게 최대 교체 수를 지정하면, 문자열에 맞는 패턴을 교체할 문자열로 교체하고 그 수가 도달하면 더 이상 교체하지 않는다.

import re


print(re.sub('a', 'z', 'ab'))
print(re.sub('a', 'zxc', 'ab'))
print(re.sub('a', 'z', 'aaaab'))
print(re.sub('a', 'z', 'aaaab', 1))


# zb
# zxcb
# zzzzb
# zaaab

subn

• subn(패턴, 교체할 문자열, 문자열, 최대 교체 수, 플래그): 는 sub()와 동작은 동일하나, 반환 결과가 (문자열, 매칭횟수)형태로 반환된다.

import re


print(re.subn('a', 'z', 'ab'))
print(re.subn('a', 'zxc', 'ab'))
print(re.subn('a', 'z', 'aaaab'))
print(re.subn('a', 'z', 'aaaab', 1))

# ('zb', 1)
# ('zxcb', 1)
# ('zzzzb', 4)
# ('zaaab', 1)

compile

• compile(패턴, 플래그)는 패턴과 플래그가 동일한 정규식을 여러번 사용하려면 compile()을 지정하여, 위의 함수들을 사용할 수 있다.

import re

c = re.compile('a')

print(c.sub('zxc', 'abcdefg'))
print(c.search('vcxdfsa'))


# zxcbcdefg
# <re.Match object; span=(6, 7), match='a'>

purge

• 위 compile()로 만들어 놓은 객체는 캐시에 보통 100여 개 까지 저장된다고 알려져있다.
• 그 수를 넘으면, 초기화된다.
• purge()를 호출하면 100개가 넘어가지 않아도 캐시를 초기화하는 함수이다.

import re

re.purge()

escape (패턴)

• escape()는 패턴을 입력 받으면 특수문자들이 이스케이브(\) 처리한 다음, 반환한다.

import re


print(re.escape('(\d)'))


# \(\\d\)

match object method()

• findall()을 제외하고 모든 한수들의 반환은 match object로 반환된다.
• match object에서는 group(), start(), end()등과 같이 찾은 패턴이 문자열의 위치나 매칭 문자열을 반환하는 함수

• group(), start(), end(), span()
• 예를 들어 search()로 패턴에 맞는 문자열을 찾았다하면, group() 메서드를 통해 패턴에 맞는 문자열을 추출 할 수 있다.
• start()를 사용해 문자열에서 어디서 부터, 패턴에 맞는 문자가 시작했는지
• end()를 통해 어디까지 인지
• span()으로 어디부터 어디까지 인지 확인 할 수 있다.

import re

result = re.search('aa', 'baab')
print(result.group())
print(result.start())
print(result.end())
print(result.span())


# aa
# 1
# 3
# (1, 3)

• groups(),group(int): 만약 위와 같이 단순한 형태가 아닌, 소괄호 ()를 사용해 패턴을 묶는다면, 아래와 같이 groups() group(int)를 사용할 수 있다.

import re

result = re.match('(\d{2})-(\d{3,4})-(\d{4})', '02-123-1234')
print(result.groups())
print(result.group())
print(result.group(0))
print(result.group(1))
print(result.group(2))

# ('02', '123', '1234')
# 02-123-1234
# 02-123-1234
# 02
# 123

• 소괄호를 사용해 패턴을 체크하고 체크한 값을 변수로 저장해야만 위의 함수들을 사용할 수 있다.
  아래는 소괄호를 전부 제거한 패턴인데 결과는 동일하지만 groups()를 사용하지 못하는 모습

import re




result2 = re.match('\d{2}-\d{3,4}-\d{4}', '02-123-1234')
print(result2.groups())
print(result2.group())

# ()
# 02-123-1234

• groupdict(): groupdict()를 사용하려면 패턴에 맞는 결과에 이름을 주어야한다. 패턴에 이름을 주려면 (?P<이름>)형식이 되어야만 한다. 여기서도 소괄호가 존재하지 않으면 에러가 발생한다.

import re

result = re.match('(?P<front>\d{2})-(?P<middle>\d{3,4})-(?P<rear>\d{4})', '02-123-1234')

print(result.groupdict())
print(result.groups())
print(result.group(1))
print(result.group('front'))


# {'front': '02', 'middle': '123', 'rear': '1234'}
# ('02', '123', '1234')
# 02
# 02

• 패턴
• 위 함수들의 가장 마지막 인자에는 패턴을 추가할 수 있으며, re 모듈은 아래와 같은 패턴을 지원한다.
  I, IGNORECASE: 대소문자 구분 X

L, LOCATE: \w, \W, \b, \B를 현재의 로케일에 영향을 받음

M, MULTILINE: 여러 줄의 문자열에 대해 패턴을 탐색할 수 있게 함

S, DOTALL: .을 줄바꾸기 문자도 포함하여 매치하게 함

U, UNICODE: \w, \W, \b, \B가 유니코드 문자 특성에 의존함

X, VERBOSE: 정규식 안의 공백 무시

위의 패턴은 아래와 같이 사용할 수 있으며 여러 패턴을 등록하려면 | 을 사용합니다.

import re

s = """
c
b
A
"""
print(re.search('a', s, re.M|re.I))


# <re.Match object; span=(5, 6), match='A'>