파이썬+정규표현식+이해하기 20160301

PYTHON
정규표현식
2.X
Moon Yong Joon

정규표현식
 정규표현식을 정의: 문자열에 대한 표현을 메타문자로 표시함
 정규표현식을 실행 : 실제 문자열을 넣고 정규식과 매칭여부 검증
패턴 문장
패턴정의
패턴실행
(패턴검색)

리터럴
 단어 등을 직접 입력하여 정규표현식 매칭
Example Description
python Match "python".

문자클래스(character class, [])
 문자클래스를 만드는 메타문자인 [와 ] 사이에는 어떤 문자 사용
 문자클래스로 만들어진 정규식은 "[과 ]사이의 문자들과 매치"라는 의미
• [a-zA-Z] : 알파벳 모두
• [0-9] : 숫자
• ^ 메타문자는 반대(not)의 의미: [^0-9]라는 정규표현식은 숫자가 아닌 문자만 매치
Example Description
[Pp]ython Match "Python" or "python"
rub[ye] Match "ruby" or "rube"
[aeiou] Match any one lowercase vowel
[0-9] Match any digit; same as [0123456789]
[a-z] Match any lowercase ASCII letter
[A-Z] Match any uppercase ASCII letter
[a-zA-Z0-9] Match any of the above
[^aeiou] Match anything other than a lowercase vowel
[^0-9] Match anything other than a digit

축약형 문자표현
 축약형 문자표현
 대문자로 사용된것은 소문자의 반대임
 d - 숫자와 매치, [0-9]와 동일한 표현식
 D - 숫자가 아닌것과 매치, [^0-9]와 동일한 표현식
 s - whitespace 문자와 매치, [ tnrfv]와 동일한 표현식이다. 맨 앞의 빈칸은 공
백문자(space)를 의미
 S - whitespace 문자가 아닌 것과 매치, [^ tnrfv]와 동일한 표현식
 w - 문자+숫자(alphanumeric)와 매치, [a-zA-Z0-9]와 동일한 표현식
 W - alphanumeric이 아닌 문자와 매치, [^a-zA-Z0-9]와 동일한 표현식

축약형 문자표현-세부
Pattern Description
w Matches word characters.
W Matches nonword characters.
s Matches whitespace. Equivalent to [tnrf].
S Matches nonwhitespace.
d Matches digits. Equivalent to [0-9].
D Matches nondigits.
A Matches beginning of string.
Z Matches end of string. If a newline exists, it matches just before newline.
z Matches end of string.
G Matches point where last match finished.
b Matches word boundaries when outside brackets. Matches backspace (0x08) when inside brackets.
B Matches nonword boundaries.
n, t, etc. Matches newlines, carriage returns, tabs, etc.
1...9 Matches nth grouped subexpression.
10 Matches nth grouped subexpression if it matched already. Otherwise refers to the octal representati
on of a character code.

문자 형식과 축약형 매핑
Vim ASCII 설명
[A-Za-z0-9] 영숫자
w [A-Za-z0-9_] 영숫자 + "_"
W [^A-Za-z0-9_] 낱말이 아닌 문자
a [A-Za-z] 알파벳 문자
s [ t] 공백과 탭
< > (?<=W)(?=w)|(?<=w)(?=W) 낱말 경계
[x00-x1Fx7F] 제어 문자
d [0-9] 숫자
D [^0-9] 숫자가 아닌 문자
[x21-x7E] 보이는 문자
l [a-z] 소문자
p [x20-x7E] 보이는 문자 및 공백 문자
[][!"#$%&'()*+,./:;<=>?@^_`{|}~-] 구두점
_s (단순히 줄 끝에 추가) [ trnvf] 공백 문자
[^ trnvf] 공백이 아닌 모든 문자
u [A-Z] 대문자
x [A-Fa-f0-9] 16진수

축약형 문자표현 : 예시
"(dw+)W(dw+)"
d : 알파벳소문자
w+ : 하나 이상의 문자
W : 문자가 아닌 캐릭터
["dog dot", "do don't", "dumb-dumb", "no match"]
('dog', 'dot') ('do', 'don') ('dumb', 'dumb')
알파벳 소문자 d 로 시작하고 하나이상의 문자스트
링 그룹+알파벳문자가 아닌 문자+알파벳 소문자
로 시작하는 하나이상의 스트링 그룹 으로 구성

Anchor (^ / $)
^
 문자열의 맨 처음과 일치함을 의미
 컴파일 옵션 re.MULTILINE 을 사용할 경우에는 여러줄의 문자열에서는 각 라인
의 처음과 일치
 ^ 문자를 메타문자가 아닌 문자 그 자체로 매치하고 싶은 경우에는 [^] 처럼 사용
하거나 ^ 로 사용
$
 문자열의 맨 마지막부터 일치함을 의미
 $ 문자를 메타문자가 아닌 문자 그 자체로 매치하고 싶은 경우에는 [$] 처럼
사용하거나 $ 로 사용

Anchor 처리 예시
Example Description
^Python Match "Python" at the start of a string or internal line
Python$ Match "Python" at the end of a string or line
APython Match "Python" at the start of a string
PythonZ Match "Python" at the end of a string
bPythonb Match "Python" at a word boundary
brubB B is nonword boundary: match "rub" in "rube" and "ruby" but not
alone
Python(?=!) Match "Python", if followed by an exclamation point.
Python(?!!) Match "Python", if not followed by an exclamation point.
 특정 위치를 고정하여 처리할 경우 사용

DOT(.)
 dot(.) 메타문자는 줄바꿈 문자인 n를 제외한 모든 문자와 매치
 re.DOTALL 이라는 옵션을 주면 n문자와도 매치의미
• a.b : "a + 모든문자 + b“
• a[.]b : "a + Dot(.)문자 + b"

백슬래시() 문제
 “section” : 이 정규식은 s 문자가 whitespace로 해석되어
[ tnrfv]ection 동일한 의미
 “section” : 파이썬 문자열 리터럴 규칙에 의하여 이 로 변경
 문자를 전달하려면 파이썬은 처럼 백슬래시를 4개나 사용
 r”section” : Raw String 규칙에 의하여 백슬래시 두개 대신 한개만 써도
두개를 쓴것과 동일한 의미

반복 ({m,n})
 {} 메타문자를 이용하면 반복횟수를 고정시킬 수 있다. {m, n} 정규식을 사용
하면 반복횟수가 m부터 n인것을 매치
 {1,}은 +와 동일하며 {0,}은 *와 동일
정규식 문자열 Match 여부 설명
ca{2}t cat No
"a"가 1번만 반복되어 매치
되지 않음
ca{2}t caat Yes "a"가 2번 반복되어 매치
ca{2,5}t cat No
"a"가 1번만 반복되어 매치
되지 않음
ca{2,5}t caat Yes "a"가 2번 반복되어 매치
ca{2,5}t caaaaat Yes "a"가 5번 반복되어 매치

반복 (*)
 *바로 앞에 있는 문자 a가 0부터 무한개 까지 반복될 수 있다는 의미
ca*t ct Yes "a"가 0번 반복되어 매치
ca*t cat Yes
"a"가 0번 이상 반복되어 매치
(1번 반복)
ca*t caaat Yes
(3번 반복)

반복 (+)
 +는 최소 1개 이상의 반복을 필요로 하는 메타문자
ca+t ct No
"a"가 0번 반복되어 매치되지
않음
ca+t cat Yes
(1번 반복)
ca+t caaat Yes
(3번 반복)

반복 (?)
 ? 메타문자가 의미하는 것은 {0, 1}
ab?c abc Yes "b"가 1번 사용되어 매치
ab?c ac Yes "b"가 0번 사용되어 매치

non-greedy (*?, +?, ??)
정규표현식은 연속적인 패턴이 있을 경우 최종까지 처리되어 non-greedy
minimal fashion 처리를 위한 기호
정규식 문자열 매칭
<.*?> <H1>title</H1> <H1>
<.+?> <H1>title</H1> <H1>
<.??> <b>title</b> <b>

Grouping 기준
Group을 만들기 위해서는 ( )를 사용하면 특수
그룹은 첫번째 (다음에 ?를 넣은 다음 (“(?”) 다양
한 문자표현을 사용해서 정규표현식 문법을 만듬
일반 (패턴)
특수 (?문자표현 패턴)

Grouping(…)
( ) 내에 정규 표현식을 정의하고 특정 단어나 특정 그
룹을 표시
정규식 문자열 설명
"([abc]).+([def])" "b===d==c" 'b===d‘ ,b, d

Grouping(…) 주의사항
“pattern”은 이 패턴에 맞는 것만 찾지만 (“pattern”)
은 패턴 검색 후 그룹단위로 출력을 처리하므로 처
리결과가 상이할 수 있음
In [70]: re.split('(W+)', 'Words, words, words')
Out[70]: ['Words', ', ', 'words', ', ', 'words']
In [71]: re.split('W+', 'Words, words, words')
Out[71]: ['Words', 'words', 'words']
In [72]: re.split('w+', 'Words, words, words')
Out[72]: ['', ', ', ', ', '']
In [73]: re.split('(w+)', 'Words, words, words')
Out[73]: ['', 'Words', ', ', 'words', ', ', 'words', '']

Grouping(…) :예시
 line = "Cats are smarter than dogs“
 matchObj = re.match( r'(.*) are (.*?) (.*)', line, re.M|re.I)
 Cats 는 (.*) 매칭 , smarter는 (.*?)와 매칭, than dogs는 (.*)와 매칭
 re.I - 대소문자에 관계없이 매치, Re.m – 여러 줄과 매치
Example Description
Dd+ DNo group: + repeats d
(Dd)+ Grouped: + repeats Dd pair
([Pp]ython(, )?)+ Match "Python", "Python, python, python", etc.
Example Description
([Pp])ython&1ails Match python&pails or Python&Pails
(['"])[^1]*1 Single or double-quoted string. 1 matches whatever the 1st group matc
hed. 2 matches whatever the 2nd group matched, etc.
 기존 그룹을 재사용하기
 기존 그룹을 숫자를 사용하여 참조하게 한다.

Named Group
( ) 내에 name을 붙여서 name 으로 패턴 매칭을
찾을 수 있는 구조를 만듬
'(?P<name>.*)
(?P<phone>.*)'
‘John 123456'
name = johe,
phone=123456
"(?P<first>w+)W+(?
P<last>w+)"
"Clyde
Griffiths"
first = Clyde
last = Griffiths

Non-capture : (?: …)
정규 표현의 괄호 안에 있지만 그룹에 의해 일치하
는 부분 문자열 비교를 수행 한 후 검색 또는 나중
에 패턴에서 참조하지 않음
"(?:(?:w{3})|(?:-
{3}))ddd$"
“cat100 “
“---200”
“cat100 “
“---200”
(?:(?:w{3})|(?:-{3})) : 패턴 내부에 3문자와 -3자 중에 선택
ddd$“ : 마지막에 숫자 3개

하위표현패턴
기존패턴에 대해 추가적인 패턴을 적용할 경우
사용하는 패턴
Example Description
(?P=name) 기존에 정의된 네임 그룹을 참조해서 처리
(?#...) 주석처리
(?=...) 전방탐색패턴
(?!...) 부정형전방탐색패턴
(?<=...) 후방탐색패턴
(?<!...) 부정형후방탐색패턴
(?(id/name)yes-
pattern|no-pattern)
미리 정의된 패턴에 대해 확인하고 그 패턴에 대한 추가 처리를

기존 네임그룹 참조(?P=name)
기존 네임 그룹 패턴을 다시 사용해서 패턴 매칭
'(?P<word>bw+)s+
(?P=word)'
'Paris in the the spring' 'the the'

주석(?#...)
패턴에 대한 주석을 추가하여 설명하므로 정규식
패턴매칭에서는 무시됨
"[abc].+(?# writing
comments)"
"abc” "abc”

전방탐색(?=...)
작성된 패턴이 있어도 그 값이 제외된 후에 표시하는 패턴
".+(?=abc)", "vvvabc" vvv

부정형전방탐색(?!...)
전방탐색은 일치한 것을 탐색하지 부정형은 일치하지 않는 것을 탐색함
".+(?!abc)" "xxx" "xxx"

후방탐색(?<=...)
자기 패턴을 검색 후에 자신을 빼고 뒤에 일치하는
것을 표시
"(?<=abc).+", "vvvabcxxx" xxx

부정형후방탐색(?<!...)
 ( ) 내에 정규 표현식을 정의하고 특정 단어나 특정 그룹을 표시
"([abc]).+([def])" "b===d==c" b, d

(?(id/name)yes…|no…)
선행 패턴에 대해 추가패턴을 표시하고 실제 성공과 실패에
대한 추가적인 처리를 하는 패턴
Nopattern은 있으나 없으면 매핑이 안되므로 생략해도 됨
'(a)(?(1)b|c)' 'ab' 'b'

Grouping(?iLmsux)
패턴 처리시 실제 작동하는 패턴의 플래그에 따른
지시에 따라 실행
Example Description
(?iLmsux) re.I (ignore case), re.L (locale dependent), re.M (multi-line), re.S (dot matc
hes all), re.U (Unicode dependent), and re.X (verbose)
(?imx: re) Temporarily toggles on i, m, or x options within parentheses.
(?-imx: re) Temporarily toggles off i, m, or x options within parentheses.

패턴변경자 -1
 i : 패턴을 대소문자 구분 없이 검사한다. 이 변경자를 사용할 경우 [a-z]로
만 검사해도 자동으로 [a-zA-Z]와 같은 기능을 하게 된다. 가장 많이 쓰이는
패턴.
 s : 임의의 한 문자를 가리키는 . 메타 문자에 개행 문자(n)도 포함시키도록
한다. 이 변경자를 사용하면 .이 줄바꿈도 임의의 한 문자로 취급하여 찾는
다.
 m : 주어진 문자열에 줄바꿈이 있을 경우, 여러 줄로 취급하여 검사한다. (줄
바꿈이 없다면 써도 의미가 없다.) 원래 정규표현식을 쓸 때 줄바꿈은 무시
되는데, 이걸 사용하면 줄바꿈을 적용해서 검사한다. 그리고 ^은 한 줄의 시
작, $는 한 줄의 끝으로 의미가 달라진다.
 x : 공백 문자를 찾지 않고 무시해 버린다. 단, 이스케이프(역슬래쉬하고 같
이 쓸 경우)하거나 문자 클래스 안에 있을 경우에는 이걸 써도 공백을 찾는
다.

패턴변경자 -2
 l : 지역에 대한 처리 기준을 따름
re.LOCALEMake w, W, b, B, s and S dependent on the current
locale.
 u : unicode 처리
re.Ure.UNICODEMake w, W, b, B, d, D, s and S dependent on
the Unicode character properties database.

정규식 정의 및 실행
 re 모듈은 파이썬이 설치될 때 자동으로 설치되는 기본 라이브러리
 p = re.compile('ab*', re.IGNORECASE) : re.IGNORECASE 옵션이 의미하는 것
은 대소문자를 구분하지 않음
>>> import re
>>> mat = re.compile("[a-z]+")
>>> mat
<_sre.SRE_Pattern object at 0x063D2C60>
>>>
>>> m = re.match('[a-z]+', "python")
>>> m.group()
'python'
>>> mo2 = re.match("[a-z]+","abc")
>>> mo2.group()
'abc'
>>>
Comile() 함수를 사용하여
실행
함수를 이용한 모듈 단위로
수행
직접 re 패키지 내의 함수(match()함수 등)
를 사용하여 실행

정규식 처리하기(1/2)
1. 정규식 객체 생성
>>> import re
>>> p = re.compile("[a-zA-Z0-9]+")
>>> p
<_sre.SRE_Pattern object at 0x06506570>
>>> p.__class__
<type '_sre.SRE_Pattern'>
>>> p.__class__.__name__
'SRE_Pattern'
>>>
2. 정규식 패턴 매칭을 위한 Match object 생성
>>> m = p.match("python")
>>> m
<_sre.SRE_Match object at 0x06556AA0>
>>> m.__class__.__name__
'SRE_Match'
>>>

정규식 처리하기(2/2)
3. 정규식 패턴 매칭 결과를 확인
>>> m.group()
'python'
>>> m.span()
(0, 6)
>>>

정규표현식 -Compile
 정규표현식 패턴객체 생성한 후 매칭을 시키는 객체를 생성하여 처리하는
방법
• Compile options
 DOTALL, S - . 이 줄바꿈 문자를 포함하여 모든 문자
 IGNORECASE, I - 대소문자에 관계없이 매치
 MULTILINE, M – 여러 줄과 매치 (^, $ 메타문자의 사용과 관계가 있는 옵션)
 VERBOSE, X - verbose 모드를 사용(정규식을 보기 편하게 만들수 있고 주석 등을 사용)
>>> re.compile('.*')
<_sre.SRE_Pattern object at 0x064AB2A8>
>>>

Compile Options- DOTALL, S
 . 메타문자는 줄바꿈 문자(n)를 제외한 모든 문자와 매치되는 규칙이 있다.
하지만 n 문자도 포함하여 매치하고 싶은 경우에는re.DOTALL 또
는 re.S 옵션으로 정규식을 컴파일하면 된다.
>>> SS = re.compile('.ake')
>>> RR = SS.match('nake')
>>> RR
>>> RR == None
True n은 .과 매치되지 않기 때문
이다. 이것이 가능하려면 다음
과 같이 re.S 옵션을 사용해야
한다.>>> SS = re.compile('.ake',re.S)
>>> RR = SS.match('nake')
>>> RR == None
False
>>> RR.group()
'nake'
>>>

Compile Options-IGNORECASE, I
 re.IGNORECASE 또는 re.I 는 대소문자 구분없이 매치를 수행하고자 할 경
우에 사용하는 옵션이다.
>>> II = re.compile('[a-z]+')
>>> ii = II.match('Python')
>>> ii == None
True
>>> [a-z] 정규식은 소문자만을 의
미하지만 re.I 옵션에 의해서
대소문자에 관계없이 매치되게
된 것이다.>>> II = re.compile('[a-z]+',re.I)
>>> ii = II.match('Python')
>>> ii == None
False
>>> ii.group()
'Python'
>>>

Compile Options-MULTILINE, M
 re.MULTILINE 또는 re.M 옵션은 메타문자인 ^, $와 연관되어 있는 옵션이다.
 ^와 $의 의미는
 ^ - 문자열의 처음, $ - 문자열의 마지막
 ^python 인 경우 처음은 항상 "python"으로 시작, python$라면 마지막은 항상 "python"으로 끝나야 매치
>>> MM = re.compile('^Hellosw+')
>>> data = """Hello World
... Hello Dahl
... Hello Moon"""
>>> mm = MM.match(data)
>>> mm.group()
'Hello World'
>>>
re.MULTILINE 옵션으로 인
해 ^메타문자가 문자열 전체가
아닌 라인의 처음이라는 의미
를 갖게 되어 다음과 같은 결과
가 출력될 것이다.>>> MM = re.compile('^Hellosw+',re.M)
>>> MM.findall(data)
['Hello World', 'Hello Dahl', 'Hello Moon']

Compile Options-VERBOSE, X
 이해하기 어려운 정규식에 주석 또는 라인단위로 구분을 하여 표시할 수 있도록 처리
>>> charref = re.compile(r'&[#](0[0-7]+|[0-
9]+|x[0-9a-fA-F]+);')
첫번째와 두번째의 컴파일된 패턴 객체는 모
두 동일한 역할을 한다.
하지만 정규식이 복잡할 경우
두번째 처럼 주석을 적고 여러줄로 표현하는
것이 훨씬 가독성이 좋다는 것을 알 수 있을 것
이다.
re.VERBOSE 옵션을 사용하면 문자열에 사용
된 whitespace 는 컴파일 시 제거된다.
(단 [] 내에 사용된 whitespace는 제외)
그리고 라인단위로 # 을 이용하여 주석문을 작
성하는 것이 가능하게 된다.
>>> charref = re.compile(r""" &[#] # Start of a
numeric entity reference ( 0[0-7]+ # Octal form | [0-
9]+ # Decimal form | x[0-9a-fA-F]+ # Hexadecimal
form ) ; # Trailing semicolon """, re.VERBOSE)

정규표현식 –Compile 후 검색
 match, search는 정규식과 매치될 때에는 match object를 리턴하고 매치되지 않을 경우
에는 None을 리턴
 match - 문자열의 처음부터 검색
 search – 문자열 내에서 일치하는 것이 있는지 검색
function 목적
match() 문자열의 처음부터 정규식과 매치되는지 조사한다.
search() 문자열 전체를 검색하여 정규식과 매치되는지 조사한다.
findall() 정규식과 매치되는 모든 라인의 문자열(substring)을 리스트로 리턴한다
finditer()
정규식과 매치되는 모든 라인의 문자열(substring)을 iterator 객체로 리턴한
다
sub() 정규식과 매치되면 변경시킴
split() 매칭되면 패턴별로 쪼개서 리턴

match 함수
 문자열에 패턴을 찾아 검색이 필요한 경우 처리match, search는 정규식과
매치될 때에는 match object를 리턴하고 매치되지 않을 경우에는 None을
리턴
함수 목적
match(패턴,문자열,플래그) 문자열의 처음부터 정규식과 매치되는지 조사한다.
search(패턴,문자열,플래그) 문자열 전체를 검색하여 정규식과 매치되는지 조사한다.
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) (.*)', line, re.M|re.I)
if matchObj:
print "matchObj.group() : ", matchObj.group()
print "matchObj.group(1) : ", matchObj.group(1)
else:
print "No match!!"
(.*) 패턴은 문자숫자가 연속
(.*?) 패턴은 문자숫자가 연속
된 것이 0또는 1
Group(숫자)는 각 패턴매칭된
결과

match – match object
 Match는 첫번째 자리부터 동일한 패턴이 발생할 때만 Object가 만들어 짐
 Match() 메소드에서 리턴하는 객체를 이용해서 메소드를 가지고 확인
Method 목적
group() 매치된 문자열을 리턴한다.
start()
매치된 문자열의 시작 위치를 리
턴한다.
end()
매치된 문자열의 끝 위치를 리턴
한다.
span()
매치된 문자열의 (시작, 끝) 에 해
당되는 튜플을 리턴한다
>>> mat
>>>
>>> mo = mat.match('abc')
>>> mo
<_sre.SRE_Match object at 0x065567C8>
>>>
>>> mo.group()
'abc'
>>>
>>> mo.start()
0
>>> mo.end()
3
>>> mo.span()
(0, 3)
>>> #동일한 패턴이 아니면 미스매칭
>>> if mat.match(" abc") == None :
... print("mismatch")
...
mismatch

search – match object
 내부에 있는 패턴을 검색하여 처음부터 매칭되는 것을 검색하여 매칭시킴
Method 목적
group() 매치된 문자열을 리턴한다.
start()
매치된 문자열의 시작 위치를 리
턴한다.
end()
매치된 문자열의 끝 위치를 리턴
한다.
span()
매치된 문자열의 (시작, 끝) 에 해
당되는 튜플을 리턴한다
>>> mat
>>>
>>> so1 = mat.search("123abc")
>>> so1
<_sre.SRE_Match object at 0x06556608>
>>> so1.group()
'abc'
>>> so1.start()
3
>>> so1.end()
6
>>> so1.span()
(3, 6)
>>>

search – named group 처리
Group 패턴에 특정 이름을 부여하고 패턴매칭 후
에 그 이름 별로 검색
import re
match = re.search('(?P<name>.*) (?P<phone>.*)', 'John 123456')
print match.group('name')
print match.group('phone')
match = re.search('(.*) (.*)', 'John 123456')
print match.group(0)
print match.groups()
#결과값
John
123456
John 123456
John
123456
('John', '123456')
Group()에서 인덱스로 조회시 그룹핑 된 결과는 인덱스가
1번부터 조회해야 함

함수:문자열 수정
 문자열에 패턴을 찾아 변경이 필요한 경우 처리match, search는 정규식과
매치될 때에는 match object를 리턴하고 매치되지 않을 경우에는 None을
리턴
함수 목적
sub(pattern,replace,st
ring)
정규식에 매칭되는 것을 변경.
phone = "010-959-559 # This is Phone Number"
# 주석제거
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
# 숫자를 제외한 모든 문자 제거
num = re.sub(r'D', "", phone)
print "Phone Num : ", num
패턴 #.*$는 #으로 시작하는
모든 문자를 $(문자열의 끝)까
지 매칭
패턴 D는 [^0-9] 즉 숫자가
아닌 문자를 매칭

함수: 함수를 이용한 수정
함수를 이용해서 매칭된 패턴을 변경
#Squaring numbers
def square(match):
number = int(match.group(0))
return str(number**2)
print re.sub(r"d+", square, "1 2 3 4 5 6 7 8 9")
#처리결과값
1 4 9 16 25 36 49 64 81

함수:Greedy vs Non-Greedy
Greedy와 Non-Greedy 에 대한 패턴을 명확히 해
서 수정해야 함
s = '<html><head><title>Title</title>'
print len(s)
print(re.match('<.*>', s).span())
print(re.match('<.*>', s).group())
print(re.match('<.*?>', s).span())
print(re.match('<.*?>', s).group())
<.*> 패턴은 모든 매칭을 다
처리해서 결과는
<html><head><title>Title
</title>'
<.*?> 패턴 첫번째만 처리해
서 결과는 <html>

findall
함수 목적
findall(pattern, string,
flags=0)
정규식에 매칭되는 것을 검색 후 리스트로 출력.
In [65]: x = "abcdef"
In [66]: re.findall(".+(?=def)",x)
Out[66]: ['abc']
In [67]: re.findall("(?=abc).+",x)
Out[67]: ['abcdef']
In [68]: re.findall("(?<=abc).+",x)
Out[68]: ['def']
In[67]은 전방인식이 안되
어서 .+로 패턴 매칭 됨

finditer
함수 목적
finditer(pattern, strin
g, flags=0)
정규식에 매칭되는 것을 검색 후 iterable 객체로 출
력되므로 실제 루핑을 처리가 필요
match =re.finditer(r'w','http://www.hackerrank.com/')
print match
for x in match :
print x.group()
<callable-iterator object at 0x10573E90>
h
t
t
p
w
w
w
h
a
c
k
e
r
r
a
n
k
c
o
m
패턴 매칭된 것을 iterable 객체로 리턴하므로 실제
match object를 처리하기 위해 looping 처리

split
함수 목적
split(pattern, string,
maxsplit=0, flags=
0)
정규식에 매칭되는 것을 검색 후 쪼개서 리스트로 출
력.
>>> re.split('W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']
In[67]은 전방인식이 안되
어서 .+로 패턴 매칭 됨

match object method
Match object 내의 메소드
Method 목적
group().groups(0, groupdict() 매치된 문자열을 리턴
start()/end() 매치된 문자열의 시작/끝 위치를 리턴한다.
findall()/finditer() 매치된 것을 리스트와 iterable 객체로 리턴
split() 매치된 결과를 split 처리하고 리스트로 리턴
span() 매치된 문자열의 (시작, 끝) 에 해당되는 튜플을 리턴한다

match object :group 메소드
Match, search 함수를 실행해서 만들어진 match
object의 group() 메소드 처리
import re
#이메일 주소에 대한 패턴인식
m = re.match(r'(w+)@(w+).(w+)','username@hackerrank.com')
print m.group(0) # 전체 매칭된 결과를 보여줌
print m.group(1) # The first parenthesized subgroup.
print m.group(2) # The second parenthesized subgroup.
print m.group(3) # The third parenthesized subgroup.
print m.group(1,2,3) # Multiple arguments give us a tuple.
#결과값
username@hackerrank.com
username
hackerrank
com
('username', 'hackerrank', 'com')

match object :groups 메소드
object의 groups() 메소드 처리
import re
m = re.match(r'(w+)@(w+).(w+)','username@hackerrank.com')
print m.groups()
#결과값
('username', 'hackerrank', 'com')

match object :groupdict 메소드
object의 groupdict() 메소드 처리
 Group을 정의시 그룹에 대한 name를 부여해
야 함
import re
m =
re.match(r'(?P<user>w+)@(?P<website>w+).(?P<extension>w+)','
myname@hackerrank.com')
print m.groupdict()
#결과값
{'website': 'hackerrank', 'user':
'myname', 'extension': 'com'}

match object :start/end/span
object의 매칭된 인덱스를 제공하는 메소드
import re
m = re.search(r'd+','1234')
print m.end()
print m.start()
print m.span()
#결과값
4
0
(0, 4)

파이썬+정규표현식+이해하기 20160301

More Related Content

Viewers also liked (20)

Similar to 파이썬+정규표현식+이해하기 20160301 (20)

More from Yong Joon Moon (20)

파이썬+정규표현식+이해하기 20160301