-
1. (๋ฌธ์์ด ์๋น๊ฐ ์๋) ๋ฉํ ๋ฌธ์ (meta characters)
์๋ ๊ทธ ๋ฌธ์๊ฐ ๊ฐ์ง ๋ป์ด ์๋, ํน๋ณํ ์ฉ๋๋ก ์ฌ์ฉํ๋ ๋ฌธ์.
. ^ $ * + ? { } [ ] \ | ( )
1) ๋ฌธ์ ํด๋์ค [ ]
[ ] ์ฌ์ด์ ๋ฌธ์๋ค๊ณผ ๋งค์น
ex) [abc] ๋ผ๋ฉด a, b, c ์ค ํ๊ฐ์ ๋ฌธ์์ ๋งค์น๋ผ๋ ๋ป.
ํ์ดํ(-) ์ ์ฌ์ฉํ๋ฉด ๋ฒ์๋ฅผ ๋ํ๋. [a, b, c] == [a-c], [0-5] ๋ฑ๋ฑ
- [a-zA-Z] : ์ํ๋ฒณ ๋ชจ๋
- [0-9] : ์ซ์
์ฃผ์ํ ์ : [ ] ์์๋ ์ด๋ค ๋ฌธ์๋ ๋ฉํ ๋ฌธ์๋ ์ฌ์ฉ ๊ฐ๋ฅํ์ง๋ง, ^์ not์ ๋ป์ ๋ํ๋ด๊ธฐ ๋๋ฌธ์ ์ฃผ์ํด์ผ ํ๋ค.
์๋๋ ์์ฃผ ์ฌ์ฉํ๋ ๋ฌธ์ ํด๋์ค ์ด๋ค.
- \d = [0-9]
- \s = whitespace ๋ฌธ์์ ๋งค์น.
- \w = ๋ฌธ์+์ซ์(alphanumeric) : word ๋ฅผ ํํํ๋ฉฐ ์ํ๋ฒณ + ์ซ์ + _ ์ค์ ํ ๋ฌธ์์์ ์๋ฏธํ๋ค.
์๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ํ๊ธฐํ๋ฉด ๋ฐ๋ ๋ป์ ๋ํ๋ธ๋ค.
2) Dot (.)
\n์ ์ ์ธํ ๋ชจ๋ ๋ฌธ์์ ๋งค์น๋จ์ ์๋ฏธํ๋ค.
ex) a.b = a + all character + b
๋ง์ฝ, a[.]b๋ก ํ๊ธฐ๋๋ค๋ฉด, ๋ชจ๋ ๋ฌธ์๊ฐ ์๋๋ผ ์ ๋ง a.b๋ค. (์ ์ผ๋ก์์ ๋ป)
3) ๋ฐ๋ณต (*)
* ์์ ์ค๋ ๋ฌธ์๊ฐ 0๋ถํฐ ๋ฌดํ๋๋ก ๋ฐ๋ณต๋ ์ ์๋ค๋ ์๋ฏธ. ์ฆ, *์์ ๋ฌธ์๊ฐ ์์ด๋ 0๋ฒ ๋ฐ๋ณต๋๊ฑธ๋ก ๋ฐ์๋ค์ฌ์ matchํด์ค๋ค.
4) ๋ฐ๋ณต (+)
์๋ ์ต์ ๋ฐ๋ณต ํ์๊ฐ 1! ๊ทธ๋๊น ์ ์ด๋ ํ๋ฒ์ ๋์์ผ ํ๋ค.
5) ๋ฐ๋ณต ({m, n})
๋ฐ๋ณต ํ์๋ฅผ ์ ํํ๊ณ ์ถ์ ๋! ์ฆ ๋ฐ๋ณต ํ์๋ฅผ ๊ณ ์ ํ ์ ์๋ค. m, n์๋ฆฌ์ ๋ฐ๋ณต ํ์๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค. m์ด ์๋ต๋๋ฉด 0์, n์ด ์๋ต๋๋ค๋ฉด ๋ฌดํ๋๋ฅผ ๋ปํ๋ค.
{1,} == +
{0,} == *
a{2}๋ผ๊ณ ํ๋ฉด, ๋ฐ๋์ a๊ฐ 2๋ฒ ๋ฐ๋ณต ๋์ด์ผ ํ๋ค.
6) ๋ฌผ์ํ ?
? == {0, 1}
์ฆ, ์์ด๋ ๋๊ณ ์๋ ๋๋ค๋ฅผ ๋ปํ๋ค.
2. re module
python์์ ์ ๊ท ํํ์์ ์ง์ํ๋ค. re = regular expression
import re p = re.compile('ab*')
re.compile ์ ์ด์ฉํด์ ์ ๊ท ํํ์์ ์ปดํ์ผ ํ๋ค. ์ด ์ปดํ์ผ์ ๊ฒฐ๊ณผ๋ก ๋ฐ๋ ๊ฐ์ฒด p๋ฅผ ์ด์ฉํด์ ์ดํ์ ์์ ์ ์ํํ๋ค.
ํจํด ๊ฐ์ฒด๋ฅผ ํ ๋ฒ๋ง ์ฌ์ฉํ ๋์ ๋ชจ๋ ๋จ์๋ก ์ํํ ์๋ ์๋ค.
m = re.match('[a-z]+', "python")
3. ์ ๊ท์์ ์ด์ฉํ ๋ฌธ์์ด ๊ฒ์
์ปดํ์ผ ๋ ํจํด ๊ฐ์ฒด๋ฅผ ์ด์ฉํด์ ๋ฌธ์์ด ๊ฒ์์ ์ํํ ์ ์๋ค.
1) match()
๋ฌธ์์ด์ ์ฒ์๋ถํฐ ์ ๊ท์๊ณผ ๋งค์น๋๋์ง ์กฐ์ฌ.
์ ๊ท์๊ณผ ๋งค์น๋๋ฉด ๋งค์น๋ ๊ฐ์ฒด๋ฅผ ๋๋ ค์ค. ์๋๋ฉด None.
์ฒ์๋ถํฐ ์กฐ์ฌํ๊ธฐ ๋๋ฌธ์ ์ฒ์๋ถํฐ ์๋๋ผ๋ฉด ๋ฐ๋ก none....
p = re.compile(์ ๊ทํํ์) m = p.match( 'string goes here' ) if m: print('Match found: ', m.group()) else: print('No match')
2) search()
๋ฌธ์์ด ์ ์ฒด๋ฅผ ๊ฒ์ํด์ ์ ๊ท์๊ณผ ๋งค์น๋๋์ง ์กฐ์ฌ.
์ ๊ท์๊ณผ ๋งค์น๋๋ฉด ๋งค์น๋ ๊ฐ์ฒด๋ฅผ ๋๋ ค์ค. ์๋๋ฉด None.
์ ์ฒด๋ฅผ ์กฐ์ฌํ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด์ ์ฒซ๋ฒ์งธ ๋ฌธ์๊ฐ ๋งค์น๋์ง ์๋๋ผ๋ ๋ค์ ๋ฌธ์๊ฐ ๋งค์น๋๋ค๋ฉด ๋ค์ ๋ฌธ์๋ฅผ ๋ฆฌํด.
3) findall()
์ ๊ท์๊ณผ ๋งค์น๋๋ ๋ชจ๋ ๋ฌธ์์ด์ ๋ฆฌ์คํธ๋ก ๋ฆฌํด
4) finditer()
์ ๊ท์๊ณผ ๋งค์น๋๋ ๋ชจ๋ ๋ฌธ์์ด์ ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๋๋ ค์ค๋ค.
4. match ๊ฐ์ฒด์ ๋ฉ์๋
match, search๋ฅผ ์ํํ ๊ฒฐ๊ณผ๋ก ๋๋ ค์ค match๊ฐ์ฒด์ ๋ํ ๋ด์ฉ์ด๋ค.
group() : ๋งค์น๋ ๋ฌธ์์ด์ ๋๋ ค์ค
start() : ๋งค์น๋ ๋ฌธ์์ด์ ์์ ์์น๋ฅผ ๋๋ ค์ค
end() : ๋ ์์น๋ฅผ ๋๋ ค์ค
span() : ์์, ๋์ ํด๋นํ๋ ํํ์ ๋๋ ค์ค.
5. ์ปดํ์ผ ์ต์
1) DOTALL, S
. ๋ฉํ ๋ฌธ์์ \n๋ ํฌํจํด์ ๋งค์นํ ์ ์๊ฒ ํ๋ค.
๋ณดํต ์ฌ๋ฌ ์ค๋ก ์ด๋ฃจ์ด์ง ๋ฌธ์์ด์์ \n์ ์๊ด์์ด ๊ฒ์ํ ๋ ๋ง์ด ์ฌ์ฉํ๋ค.
p = re.compile('a.b', re.DOTALL) m = p.match('a\nb')
2) IGNORECASE, I
๋์๋ฌธ์ ๊ตฌ๋ณ ์์ด ๋งค์น๋ฅผ ์ํํ ์ ์๊ฒ ํ๋ค.
3) MULTILINE, M
^, $ ๋ฉํ ๋ฌธ์๋ฅผ ๋ฌธ์์ด์ ๊ฐ ์ค๋ง๋ค ์ ์ฉํด ์ค๋ค.
4)VERBOSE, X
์ ๊ท์์ ์ค ๋จ์๋ก ๊ตฌ๋ถํ ์ ์๊ฒํด์ค๋ค.
์ด ์ต์ ์ ์ฌ์ฉํ๋ฉด ๋ฌธ์์ด์ ์ฌ์ฉ๋ whitespace๋ ์ปดํ์ผ ํ ๋ ์ ๊ฑฐ๋๋ค.
6. (๋ฌธ์์ด ์๋น๊ฐ ์๋) ๋ฉํ ๋ฌธ์
1) | (or)
A|B ๋ผ๋ฉด A๋๋ B๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ค.
p = re.compile('Crow|Servo') m = p.match('CrowHello') # Crow return
2) ^
๋ฌธ์์ด์ ๋งจ ์ฒ์๊ณผ ์ผ์นํจ์ ์๋ฏธ. ์ฆ, ์ฐพ๋ ๋ฌธ์์ด์ด ๋งจ ์ฒ์์ ์์ ๋๋ง ๋ฆฌํดํ๊ณ , ์๋๋ฉด none์ ๋ณด์ธ๋ค.
re.MULTILIENE์ ์ฌ์ฉํ๋ค๋ฉด, ์ฌ๋ฌ์ค์ ๋ฌธ์์ด์ผ ๊ฒฝ์ฐ ๊ฐ๊ฐ ์ค์ ์ฒ์์ ๋ปํ๋ค.
์ฐพ๋ ๋ฌธ์์ ์์ ์ฌ์ฉํ๋ค.
3) $
^์ ๋ฐ๋๋ก ๋ฌธ์์ด์ ๋๊ณผ ๋งค์นํจ์ ์๋ฏธํ๋ค.
์ฐพ๋ ๋ฌธ์ ๋ค์ ์ฌ์ฉํ๋ค.
^๊ณผ $์ ๊ทธ๋ฅ ๋ฌธ์ ๊ทธ ์์ฒด๋ก ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด ๋ฐฑ์ฌ๋์ \ ๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
4) \A
\A๋ ๋ฌธ์์ด์ ์ฒ์๊ณผ ๋งค์น๋จ์ ์๋ฏธํ๋ค. ^๊ณผ ๋์ผํ ์๋ฏธ์ง๋ง, MULTILINE์ต์ ์ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
5) \Z
๋ฌธ์์์ ๋๊ณผ ๋งค์น๋จ์ ์๋ฏธํ๋ค. $๊ณผ ๋์ผํ ์๋ฏธ์ง๋ง, MULTILINE์ต์ ์ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
6) \b
๋จ์ด ๊ตฌ๋ถ์(word boundary)์ด๋ค. ๋จ์ด๋ whitespace์ ์ํด ๊ตฌ๋ถ๋๋ค.(๋ณดํต) ์ฌ์ฉํ ๋, ํ์ด์ฌ ๋ฆฌํฐ๋ด ๊ท์น์ ์ํด \b๊ฐ ๋ฐฑ์คํ์ด์ค๊ฐ ์๋์ ๋ํ๋ด๊ธฐ ์ํด ์์ r์ ๋ฐ๋์ ๋ถ์ฌ์ค์ผ ํ๋ค.
Ex) r'\bclass\b'
7) \B
์์ ๋ฐ๋๋ก, whitespace๋ก ๊ตฌ๋ถ๋์ง ์์ ๋จ์ด๋ง ๋งค์น.
7. ๊ทธ๋ฃจํ ( )
๋ฌธ์ ๊ฐ๊ฐ์ธ์ผ๋ก ๋ณด๋๊ฒ ์๋๋ผ, ๊ทธ๋ฃน์ผ๋ก ๋ฌถ์ด์ ๋ณผ ์ ์๊ฒ ํด์ค๋ค!
Ex) (ABC)+
๊ทธ๋ฃน์ ์ฌ์ฉํ๋ ๋ณด๋ค ํฐ ์ด์ ๋ ๋งค์น๋ ๋ฌธ์์ด ์ค์์ ํน์ ๋ถ๋ถ์ ๋ฌธ์์ด๋ง ๋ฝ์๋ด๊ธฐ ์ํด์์ธ ๊ฒฝ์ฐ๊ฐ ๋ ๋ง๋ค.
p = re.compile(r"\w+\s+\d+[-]\d+[-]\d+") m = p.search("park 010-1234-1234")
์ด๋ฆ + " " + ์ ํ๋ฒํธ ํํ์ ๋ฌธ์์ด์ ์ฐพ๋ ์ ๊ท์์ด๋ค. ์ด ๋ฌธ์์ด์์ ์ด๋ฆ๋ง ๋ฝ์๋ด๊ณ ์ถ๋ค๋ฉด?
p = re.compile(r"(\w+)\s+\d+[-]\d+[-]\d+") m = p.search("park 010-1234-1234") print(m.group(1)) #park
group์ ์ธ๋ฑ์ค๋ 0์ด ๋งค์น๋ ์ ์ฒด ๋ฌธ์์ด, ๊ทธ๋ฆฌ๊ณ 1๋ถํฐ ์ฒซ๋ฒ์งธ, 2๊ฐ ๋๋ฒ์จฐ ๊ทธ๋ฃน ๋ฑ๋ฑ์ ๋งค์นํ๋ค.
๊ทธ๋ฃน์ ์ค์ ํด์ ์์ ์๋ ์๋ค!
(\w+)\s+((\d+)[-]\d+[-]\d+)
์ด๋ ๊ฒ ๊ทธ๋ฃจํ ํ๊ฒ ๋๋ค๋ฉด 1 - ์ด๋ฆ, 2 - ์ ํ๋ฒํธ, 3-๊ตญ๋ฒ ์ด ๋๋ค.
1) ๊ทธ๋ฃจํ๋ ๋ฌธ์์ด ์ฌ์ฐธ์กฐ
(\b\w+)\s+\1
(๊ทธ๋ฃน) + " " + ๊ทธ๋ฃน๊ณผ ๋์ผํ ๋จ์ด์๋ํ๋ฉด \1์ด ์ ๊ท์์ ๊ทธ๋ฃน ์ค ์ฒซ ๋ฒ์งธ ๊ทธ๋ฃน์ ๊ฐ๋ฆฌํค๊ธฐ ๋๋ฌธ์ด๋ค. ๋ ๋ฒ์งธ ๊ทธ๋ฃน์ ์ฐธ์กฐํ๋ ค๋ฉด \2๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
2) ๊ทธ๋ฃจํ๋ ๋ฌธ์์ด ์ด๋ฆ ๋ถ์ด๊ธฐ
(?P<๊ทธ๋ฃน๋ช >...)
์ด ํ์ฅ ๊ตฌ๋ฌธ์ ์ฌ์ฉํ๋ฉด, ๊ทธ๋ฃน์ ์ด๋ฆ์ ์ง์ด์ค ์ ์๋ค.
p = re.compile(r"(?P<name>\w+)\s+((\d+)[-]\d+[-]\d+)") m = p.search("park 010-1234-1234") print(m.group("name")) #park
์ด๋ฆ์ผ๋ก ์ฌ์ฐธ์กฐ๋ ํ ์ ์๋ค.
(?P=๊ทธ๋ฃน์ด๋ฆ)
p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)') p.search('Paris in the the spring').group() #the the
8. ์ ๋ฐฉ ํ์
Lookahead Assertions!
1) ๊ธ์ ํ ์ ๋ฐฉ ํ์
(?=...)์ ์ฌ์ฉ
...์ ํด๋น๋๋ ์ ๊ท์๊ณผ ๋งค์น๋์ด์ผ ํ๋ฉฐ, ์กฐ๊ฑด์ด ํต๊ณผ๋์ด๋ ๋ฌธ์์ด ์๋น NO!
(์ฌ๊ธฐ์ ์๋น๋์ง ์๋๋ค๋ ๋ป์, match๋ฅผ ๋ฆฌํดํ ๋ ํฌํจ๋์ง ์๋๋ค๋ ๋ป
์ฆ, ๊ฒ์์๋ ํฌํจ๋์ง๋ง ๊ฒ์ ๊ฒฐ๊ณผ์์๋ ์ ์ธ๋๋ค!)
2) ๋ถ์ ํ ์ ๋ฐฉ ํ์
(?!...)์ ์ฌ์ฉ
...์ ํด๋น๋๋ ์ ๊ท์๊ณผ ๋งค์น๋์ง ์์์ผ ํ๋ฉฐ, ์กฐ๊ฑด์ด ํต๊ณผ๋์ด๋ ๋ฌธ์์ด ์๋น NO!
9. ๋ฌธ์์ด ๋ฐ๊พธ๊ธฐ
sub ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ์ ๊ท์๊ณผ ๋งค์น๋๋ ๋ถ๋ถ์ ๋ค๋ฅธ ๋ฌธ์๋ก ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋ค.
sub ๋ฉ์๋์ ์ฒซ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ ๋ฐ๊ฟ ๋ฌธ์์ด, ๋ ๋ฒ์จฐ ๋งค๊ฐ๋ณ์๋ ๋์ ๋ฌธ์์ด์ด ๋๋ค. ๊ทธ๋ผ ๋์ ๋ฌธ์์ด์์ ํํฐ๋ก ๊ฑธ๋ฆฌ๋ ๋ถ๋ถ๋ง ๋ฐ๊ฟ ๋ฌธ์์ด๋ก ๋ฐ๋๊ฒ ๋๋ค!
p = re.compile('(blue|white|red)') p.sub('colour', 'blue socks and red shoes') #'colour socks and colour shoes'
๋ฑ ํ๋ฒ๋ง ๋ฐ๊พธ๊ณ ์ถ๋ค๋ฉด ์ธ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก count๊ฐ์ ๋๊ธฐ๋ฉด ๋๋ค.
p.sub('colour', 'blue socks and red shoes', count=1) #'colour socks and red shoes'
10. ์์ฃผ ์ฐ๋ ํํ๋ค
1) ์ซ์๋ง : ^[0-9]*$
2) ์๋ฌธ์๋ง : ^[a-zA-Z]*$
3) ํ๊ธ๋ง : ^[๊ฐ-ํฃ]*$
4) ์์ด & ์ซ์๋ง : ^[a-zA-Z0-9]*$
5) E-Mail : ^[a-zA-Z0-9]+@[a-zA-Z0-9]+$
6) ํด๋ํฐ : ^01(?:0|1|[6-9]) - (?:\d{3}|\d{4}) - \d{4}$
7) ์ผ๋ฐ์ ํ : ^\d{2,3} - \d{3,4} - \d{4}$
8) ์ฃผ๋ฏผ๋ฑ๋ก๋ฒํธ : \d{6} \- [1-4]\d{6}
9) IP ์ฃผ์ : ([0-9]{1,3}) \. ([0-9]{1,3}) \. ([0-9]{1,3}) \. ([0-9]{1,3})
Reference
https://hamait.tistory.com/342
'๐STUDY > Etc' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
RDPWrap ์๊ฒฉ ๋ฐ์คํฌํฑ ์ธ์ ๋ค์ค ์ ์ (0) 2022.03.02 Federated Learning ๋ด ๋ง๋๋ก ์ ๋ฆฌ (1) 2021.11.22 VMWare Ubuntu 16.07์์ ROS UVC_camera ์คํํ๊ธฐ (0) 2021.10.31 ๊ทธ๋ ์ด ์ฝ๋ Gray code? (0) 2020.02.28 ์ดํญ ๊ณ์ ๋ด ๋ง๋๋ก ์ ๋ฆฌ(with ์ฌ๊ท) (0) 2020.02.27 ๋๊ธ