๋ค์์ ์ ํํฌ ํ์ด์ฌ wikidocs.net/1669์ ์ ๊ทํํ์ ๋ด์ฉ์ ์กฐ๊ธ ๋ ๊ฐ๋ตํ ํ ๋ด์ฉ์ ๋๋ค.
๋ฌธ์ ํด๋์ค [ ]
"[] ์ฌ์ด์ ๋ฌธ์๋ค๊ณผ ๋งค์น"
[abc]๋ผ๋ฉด, "a,b,c ์ค ํ ๊ฐ์ ๋ฌธ์์ ๋งค์น"
์์ ํ์ดํ(-)๋ฅผ ์ฌ์ฉํ๋ฉด, From - To๋ฅผ ์๋ฏธํ๋ค.
[0-5]๋ [012345]์ ๋์ผํ๋ค.
[a-zA-Z], "์ํ๋ฒณ ๋ชจ๋"
๋ฌธ์ ํด๋์ค([])์ ^๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ not๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค.
์์ฃผ ์ฌ์ฉํ๋ ๋ฌธ์ ํด๋์ค
\d - ์ซ์์ ๋งค์น, [0-9]์ ๋์ผํ๋ค
\D - ์ซ์๊ฐ ์๋ ๊ฒ๊ณผ ๋งค์น, [^0-9]์ ๋์ผ
\s - space์ ๋งค์น
\S - space๊ฐ ์๋ ๊ฒ๊ณผ ๋งค์น
\w - ๋ฌธ์+์ซ์์ ๋งค์น, [a-zA-Z0-9_]์ ๋์ผํ๋ค.
\W - ๋ฌธ์+์ซ์๊ฐ ์๋ ๊ฒ๊ณผ ๋งค์น
Dot(.)
\n์ ์ ์ธํ ๋ชจ๋ ๋ฌธ์์ ๋งค์น๋๋ค.
"a + ๋ชจ๋ ๋ฌธ์ + b"
"aab", "a0b", "abc" ์ค "aab", "a0b"๋ ์ ๊ท์ a.b
์ ๋งค์น๋๊ณ , "abc"๋ ๋งค์น๋์ง ์๋๋ค.
์ ๊ท์ a\[.\]b
๋ "a.b"์ ๋งค์น๋๊ณ , "a0b"์๋ ๋งค์น๋์ง ์๋๋ค.
๋ฐ๋ณต \, +, {}*
*, + ๋ ๋ค ๋ฐ๋ณต์ ์๋ฏธํ์ง๋ง, +์ ๊ฒฝ์ฐ ์ต์ 1๋ฒ ์ด์ ๋ฐ๋ณต๋ ๋ ์ฌ์ฉํ๋ค.
ca*t ⇒ ct, cat, caat, caaat....
์ฌ๊ธฐ์์ ์ ๊น ์๊ฐํด ๋ณผ ๊ฒ ์๋ค. ๋ฐ๋ณต ํ์๋ฅผ 3ํ๋ง ๋๋ 1ํ๋ถํฐ 3ํ๊น์ง๋ง์ผ๋ก ์ ํํ๊ณ ์ถ์ ์๋ ์์ง ์์๊น?
{3,}์ฒ๋ผ ์ฌ์ฉํ๋ฉด ๋ฐ๋ณต ํ์๊ฐ 3 ์ด์์ธ ๊ฒฝ์ฐ์ด๊ณ {,3}์ฒ๋ผ ์ฌ์ฉํ๋ฉด ๋ฐ๋ณต ํ์๊ฐ 3 ์ดํ๋ฅผ ์๋ฏธํ๋ค. ์๋ต๋ m์ 0๊ณผ ๋์ผํ๋ฉฐ, ์๋ต๋ n์ ๋ฌดํ๋(2์ต ๊ฐ ๋ฏธ๋ง)์ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค.
โป {1,}์ +์ ๋์ผํ๊ณ , {0,}์ *์ ๋์ผํ๋ค.
{ }์ ์ฌ์ฉํ ๋ช ๊ฐ์ง ์ ๊ท์์ ์ดํด๋ณด์.
1. {}
ca{2}t
์ ๊ท์์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ๋ค.
"c + a(๋ฐ๋์ 2๋ฒ ๋ฐ๋ณต) + t"
- ca{2,5}t ⇒ caat, caaat, caaaat, caaaat ์ ๋งค์น๋๋ค.
๋ฐ๋ณต์ ์๋์ง๋ง ์ด์ ๋น์ทํ ๊ฐ๋ ์ผ๋ก ? ์ด ์๋ค. ? ๋ฉํ๋ฌธ์๊ฐ ์๋ฏธํ๋ ๊ฒ์ {0, 1} ์ด๋ค.
๋ค์ ์ ๊ท์์ ๋ณด์.
ab?c
"a + b(์์ด๋ ๋๊ณ ์์ด๋ ๋๋ค) + c"
ํ์ด์ฌ์์ ์ ๊ท ํํ์์ ์ง์ํ๋ re ๋ชจ๋
import re
p = re.compile('ab\*')
re.compile์ ์ฌ์ฉํ์ฌ ์ ๊ท ํํ์(์ ์์์๋ ab\*
)์ ์ปดํ์ผํ๋ค. re.compile์ ๊ฒฐ๊ณผ๋ก ๋๋ ค์ฃผ๋ ๊ฐ์ฒด p(์ปดํ์ผ๋ ํจํด ๊ฐ์ฒด)๋ฅผ ์ฌ์ฉํ์ฌ ๊ทธ ์ดํ์ ์์
์ ์ํํ ๊ฒ์ด๋ค.
์ปดํ์ผ ๋ ๊ฐ์ฒด๋ ๋ค์๊ณผ ๊ฐ์ ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
์ ๊ท์์ ์ด์ฉํ ๋ฌธ์์ด ๊ฒ์
์ด์ ์ปดํ์ผ๋ ํจํด ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด ๊ฒ์์ ์ํํด ๋ณด์. ์ปดํ์ผ๋ ํจํด ๊ฐ์ฒด๋ ๋ค์๊ณผ ๊ฐ์ 4๊ฐ์ง ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
match() | ๋ฌธ์์ด์ ์ฒ์๋ถํฐ ์ ๊ท์๊ณผ ๋งค์น๋๋์ง ์กฐ์ฌํ๋ค. |
search() | ๋ฌธ์์ด ์ ์ฒด๋ฅผ ๊ฒ์ํ์ฌ ์ ๊ท์๊ณผ ๋งค์น๋๋์ง ์กฐ์ฌํ๋ค. |
findall() | ์ ๊ท์๊ณผ ๋งค์น๋๋ ๋ชจ๋ ๋ฌธ์์ด(substring)์ ๋ฆฌ์คํธ๋ก ๋๋ ค์ค๋ค. |
finditer() | ์ ๊ท์๊ณผ ๋งค์น๋๋ ๋ชจ๋ ๋ฌธ์์ด(substring)์ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๋๋ ค์ค๋ค. |
match, search๋ ์ ๊ท์๊ณผ ๋งค์น๋ ๋๋ match ๊ฐ์ฒด๋ฅผ ๋๋ ค์ฃผ๊ณ , ๋งค์น๋์ง ์์ ๋๋ None์ ๋๋ ค์ค๋ค. ์ด๋ค ๋ฉ์๋์ ๋ํ ๊ฐ๋จํ ์๋ฅผ ์ดํด๋ณด์.
โป match ๊ฐ์ฒด๋ ์ ๊ท์์ ๊ฒ์ ๊ฒฐ๊ณผ๋ก ๋๋ ค์ฃผ๋ ๊ฐ์ฒด์ด๋ค.
์ฐ์ ๋ค์๊ณผ ๊ฐ์ ํจํด์ ๋ง๋ค์ด ๋ณด์.
import re
p = re.compile('\[a-z\]+')
import re
p = re.compile('\[a-z\]+')
m = p.match("python")
>>> print(m)
<\_sre.SRE\_Match object at 0x01F3F9F8>
๋ง์ฝ ์ ๊ทํํ์๊ณผ ๋ฌธ์์ด์ด ๋งค์นํ๋ค๋ฉด, Match ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ค.
match ๊ฐ์ฒด์ ๋ฉ์๋
์, ์ด์ match ๋ฉ์๋์ search ๋ฉ์๋๋ฅผ ์ํํ ๊ฒฐ๊ณผ๋ก ๋๋ ค์ค match ๊ฐ์ฒด์ ๋ํด ์์๋ณด์. ์์์ ์ ๊ท์์ ์ฌ์ฉํ ๋ฌธ์์ด ๊ฒ์์ ์ํํ๋ฉด์ ์๋ง๋ ๋ค์๊ณผ ๊ฐ์ ๊ถ๊ธ์ฆ์ด ์๊ฒผ์ ๊ฒ์ด๋ค.
- ์ด๋ค ๋ฌธ์์ด์ด ๋งค์น๋์๋๊ฐ?
- ๋งค์น๋ ๋ฌธ์์ด์ ์ธ๋ฑ์ค๋ ์ด๋์๋ถํฐ ์ด๋๊น์ง์ธ๊ฐ?
match ๊ฐ์ฒด์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ด ๊ฐ์ ๊ถ๊ธ์ฆ์ ํด๊ฒฐํ ์ ์๋ค. ๋ค์ ํ๋ฅผ ๋ณด์.
group() | ๋งค์น๋ ๋ฌธ์์ด์ ๋๋ ค์ค๋ค. |
start() | ๋งค์น๋ ๋ฌธ์์ด์ ์์ ์์น๋ฅผ ๋๋ ค์ค๋ค. |
end() | ๋งค์น๋ ๋ฌธ์์ด์ ๋ ์์น๋ฅผ ๋๋ ค์ค๋ค. |
span() | ๋งค์น๋ ๋ฌธ์์ด์ (์์, ๋)์ ํด๋นํ๋ ํํ์ ๋๋ ค์ค๋ค. |
๋ค์ ์๋ก ํ์ธํด ๋ณด์.
m = p.match("python")
>>> m.group() 'python'
>>> m.start() 0
>>> m.end() 6
>>> m.span() (0, 6)
[๋ชจ๋ ๋จ์๋ก ์ํํ๊ธฐ]
์ง๊ธ๊น์ง ์ฐ๋ฆฌ๋ re.compile์ ์ฌ์ฉํ์ฌ ์ปดํ์ผ๋ ํจํด ๊ฐ์ฒด๋ก ๊ทธ ์ดํ์ ์์ ์ ์ํํ๋ค. re ๋ชจ๋์ ์ด๊ฒ์ ์ข ์ถ์ฝํ ํํ๋ก ์ฌ์ฉํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ค. ๋ค์ ์๋ฅผ ๋ณด์.
>>> p = re.compile('\[a-z\]+')
>>> m = p.match("python")
์ ์ฝ๋๊ฐ ์ถ์ฝ๋ ํํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
>>> m = re.match('\[a-z\]+', "python")
์ ์์ฒ๋ผ ์ฌ์ฉํ๋ฉด ์ปดํ์ผ๊ณผ match ๋ฉ์๋๋ฅผ ํ ๋ฒ์ ์ํํ ์ ์๋ค. ๋ณดํต ํ ๋ฒ ๋ง๋ ํจํด ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ๋ฒ ์ฌ์ฉํด์ผ ํ ๋๋ ์ด ๋ฐฉ๋ฒ๋ณด๋ค re.compile์ ์ฌ์ฉํ๋ ๊ฒ์ด ํธํ๋ค.
๋ฉํ ๋ฌธ์
^
^ ๋ฉํ ๋ฌธ์๋ ๋ฌธ์์ด์ ๋งจ ์ฒ์๊ณผ ์ผ์นํจ์ ์๋ฏธํ๋ค.
์ ๊ท์ ^python\s\w+์ python์ด๋ผ๋ ๋ฌธ์์ด๋ก ์์ํ๊ณ ๊ทธ ๋ค์ whitespace, ๊ทธ ๋ค์ ๋จ์ด๊ฐ ์์ผ ํ๋ค๋ ์๋ฏธ์ด๋ค. ๊ฒ์ํ ๋ฌธ์์ด data๋ ์ฌ๋ฌ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
re.search('^Life', 'Life is too short')
|
| ๋ฉํ ๋ฌธ์๋ or๊ณผ ๋์ผํ ์๋ฏธ๋ก ์ฌ์ฉ๋๋ค. A|B๋ผ๋ ์ ๊ท์์ด ์๋ค๋ฉด A ๋๋ B๋ผ๋ ์๋ฏธ๊ฐ ๋๋ค.
p = re.compile('Crow|Servo')
$
$ ๋ฉํ ๋ฌธ์๋ ^ ๋ฉํ ๋ฌธ์์ ๋ฐ๋์ ๊ฒฝ์ฐ์ด๋ค. ์ฆ $๋ ๋ฌธ์์ด์ ๋๊ณผ ๋งค์นํจ์ ์๋ฏธํ๋ค.
re.search('short$', 'Life is too short')
\A
\\A๋ ๋ฌธ์์ด์ ์ฒ์๊ณผ ๋งค์น๋จ์ ์๋ฏธํ๋ค. ^ ๋ฉํ ๋ฌธ์์ ๋์ผํ ์๋ฏธ์ด์ง๋ง re.MULTILINE ์ต์ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๋ค๋ฅด๊ฒ ํด์๋๋ค. re.MULTILINE ์ต์ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ ^์ ๊ฐ ์ค์ ๋ฌธ์์ด์ ์ฒ์๊ณผ ๋งค์น๋์ง๋ง \\A๋ ์ค๊ณผ ์๊ด์์ด ์ ์ฒด ๋ฌธ์์ด์ ์ฒ์ํ๊ณ ๋ง ๋งค์น๋๋ค.
\Z
\\Z๋ ๋ฌธ์์ด์ ๋๊ณผ ๋งค์น๋จ์ ์๋ฏธํ๋ค. ์ด๊ฒ ์ญ์ \\A์ ๋์ผํ๊ฒ re.MULTILINE ์ต์ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ $ ๋ฉํ ๋ฌธ์์๋ ๋ฌ๋ฆฌ ์ ์ฒด ๋ฌธ์์ด์ ๋๊ณผ ๋งค์น๋๋ค.
\b
\\b๋ ๋จ์ด ๊ตฌ๋ถ์(Word boundary)์ด๋ค. ๋ณดํต ๋จ์ด๋ whitespace์ ์ํด ๊ตฌ๋ถ๋๋ค.
๋ค์ ์๋ฅผ ๋ณด์.
>>> p = re.compile(r'\\\\bclass\\\\b')
>>> print(p.search('no class at all'))
<re.Match object; span=(3, 8), match='class'>
\\bclass\\b ์ ๊ท์์ ์๋ค๊ฐ whitespace๋ก ๊ตฌ๋ถ๋ class๋ผ๋ ๋จ์ด์ ๋งค์น๋จ์ ์๋ฏธํ๋ค. ๋ฐ๋ผ์ no class at all์ class๋ผ๋ ๋จ์ด์ ๋งค์น๋จ์ ํ์ธํ ์ ์๋ค.
>>> print(p.search('the declassified algorithm'))
None
์ ์์ the declassified algorithm ๋ฌธ์์ด ์์๋ class ๋ฌธ์์ด์ด ํฌํจ๋์ด ์๊ธด ํ์ง๋ง whitespace๋ก ๊ตฌ๋ถ๋ ๋จ์ด๊ฐ ์๋๋ฏ๋ก ๋งค์น๋์ง ์๋๋ค.
\B
\\B ๋ฉํ ๋ฌธ์๋ \\b ๋ฉํ ๋ฌธ์์ ๋ฐ๋์ ๊ฒฝ์ฐ์ด๋ค. ์ฆ whitespace๋ก ๊ตฌ๋ถ๋ ๋จ์ด๊ฐ ์๋ ๊ฒฝ์ฐ์๋ง ๋งค์น๋๋ค.
>>> p = re.compile(r'\\\\Bclass\\\\B')
>>> print(p.search('no class at all'))
None
>>> print(p.search('the declassified algorithm'))
<re.Match object; span=(6, 11), match='class'>