정규 표현 식 (python 3)

글 목록

정규 표현 식 (python 3)

match 방법

검색 방법

상용 일치 문자

택 일 일치 문자 (|) 와 목록

중복 수량 한정 부적

네 이 티 브 문자열

경계 문자

조별

기타 상용 함수

sub, subn 함수

compile 함수

findall 함수

split 함수

정규 표현 식 (python 3)
정규 표현 식 은 문자 조작 에 대한 논리 적 공식 으로 미리 정 의 된 특정한 문자 와 특정한 문자 의 조합 으로 '규칙 문자열' 을 구성 하 는 것 입 니 다. 이 '규칙 문자열' 은 문자열 에 대한 여과 논 리 를 표현 하 는 데 사 용 됩 니 다.
역할.
1. 주어진 문자열 이 정규 표현 식 의 필터 논리 에 맞 는 지 여부 ("일치" 라 고 함).
2. 정규 표현 식 을 통 해 문자열 에서 우리 가 원 하 는 특정 부분 을 가 져 올 수 있 습 니 다.
3. 대상 문자열 을 바 꿀 수도 있 습 니 다.
match 방법
re. match 는 문자열 의 시작 위치 에서 패턴 과 일치 하려 고 시도 합 니 다. 시작 위치 가 일치 하지 않 으 면 match () 는 None 로 돌아 갑 니 다.

re.match(pattern,string,flags = 0)

함수 매개 변수 설명
매개 변수
묘사 하 다.
pattern
일치 하 는 정규 표현 식
string
일치 할 문자열
flags
표지 위치, 정규 표현 식 의 일치 방식 을 제어 하 는 데 사 용 됩 니 다. 예: 대소 문자 구분 여부, 다 중 줄 일치 여부 등 (선택 가능 한 표지)
수식 부호
묘사 하 다.
re.I
대소 문자 에 민감 하지 않 게 일치 시 키 기
re.L
현지 화 식별 (locale - aware) 일치
re.M
여러 줄 일치, 영향 ^ $
re.S
줄 바 꿈 을 포함 한 모든 문자 와 일치 합 니 다.
re.U
유 니 코드 문자 집합 에 따라 문 자 를 해석 합 니 다. 영향 \ \ w, \ W, \ b, \ B
re.X
이 표 지 는 더욱 유연 한 형식 을 준다.

#match     
import re
s = 'hello python'
pattern = 'Hello'
o = re.match(pattern,s,re.I)
print(re.match(pattern,s))
print(dir(o))#             
print(o.group())#        
print(o.span())#        
print(o.start())

검색 방법

re.match(pattern,string,flags = 0)

search 함수 매개 변수 설명
매개 변수
묘사 하 다.
pattern
일치 하 는 정규 표현 식
string
일치 할 문자열
flags
표지 위치, 정규 표현 식 의 일치 방식 을 제어 하 는 데 사 용 됩 니 다. 예: 대소 문자 구분 여부, 다 중 줄 일치 여부 등 (선택 가능 한 표지)
search 와 match 의 차이
re. match 는 문자열 의 시작 만 일치 합 니 다. 문자열 이 정규 표현 식 에 맞지 않 으 면 일치 하지 않 습 니 다. 함 수 는 None 으로 돌아 가 고 re. search 는 일치 하 는 문자열 을 찾 을 때 까지 전체 문자열 과 일치 합 니 다.

m = 'i love you'
print(re.search('love',m))
print(re.match('love',m))
###################  #############################
<re.Match object; span=(2, 6), match='love'>
None

상용 일치 문자
기호.
묘사 하 다.
.
임의의 문자 일치 (제외)
[]
목록 에 있 는 문자열 일치
\w
알파벳, 숫자, 밑줄 일치 (a - z, A - Z, 0 - 9,)
\W
일치 하 는 것 은 알파벳, 숫자, 밑줄 이 아 닙 니 다.
\s
공백 문자 와 일치 합 니 다. (공백 \ t)
\S
공백 이 아 닌 문자 일치
\d
일치 하 는 숫자 (0 - 9)
\D
비 숫자 문자 일치
부분 일치 문자 테스트

#
import re
##########.   ###############
q = 'a'
w = 'A'
e = '_'
r = '
'
pattern = '.'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'
',w1,'
',e1,'
',r1)
#########\d   ###########
q = '0123'#          
w = '5'
e = 'a'
r = ' 9'
pattern = '\d'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'
',w1,'
',e1,'
',r1)
##########\s   #############
q = ' '
w = '
'
e = '\t'
r = '_'
pattern = '\s'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'
',w1,'
',e1,'
',r1)
##############[]   #############
q = '2'
w = '3'
e = '4'
pattern = '[2468]'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
print(q1,'
',w1,'
',e1)


#################    #########################################

<re.Match object; span=(0, 1), match='a'> 
 <re.Match object; span=(0, 1), match='A'> 
 <re.Match object; span=(0, 1), match='_'> 
 None
<re.Match object; span=(0, 1), match='0'> 
 <re.Match object; span=(0, 1), match='5'> 
 None 
 None
<re.Match object; span=(0, 1), match=' '> 
 <re.Match object; span=(0, 1), match='
'> 
 <re.Match object; span=(0, 1), match='\t'> 
 None
<re.Match object; span=(0, 1), match='2'> 
 None 
 <re.Match object; span=(0, 1), match='4'>

Process finished with exit code 0

일치 하 는 문자 (|) 와 목록 선택

import re
#         
pattern = '[xyz]'
pa1 = 'x|y|z'
s = 'z'
o = re.search(pattern,s)
o1 = re.search(pa1,s)
print(o,'
',o1)
print('#########   #######')
#         
pattern = '[ab][cd]'
pa1 = 'ab|cd'
s1 = 'bc'
s2 = 'ab'
o1 = re.search(pattern,s1)
o2 = re.search(pattern,s2)
a1 = re.search(pa1,s1)
a2 = re.search(pa1,s2)
print(o1,'
',o2,'
',a1,'
',a2)




################  ##############################
<re.Match object; span=(0, 1), match='z'> 
 <re.Match object; span=(0, 1), match='z'>
#########   #######
<re.Match object; span=(0, 2), match='bc'> 
 None 
 None 
 <re.Match object; span=(0, 2), match='ab'>

Process finished with exit code 0

중복 수량 한정 부적
표현 식 의 일부분 을 중복 처리 하 는 기능 을 제공 합 니 다.
정규 표현 식 에서 자주 사용 되 는 한정 문자
기호.
묘사 하 다.
*
0 회 혹은 여러 번 일치
+
한 번 또는 여러 번 일치
？
한 번 또는 0 번 일치
{m}
반복 m 회
{m,n}
m ~ n 회 반복
{m，}
최소 m 회
부분 한정 문자 테스트

import re
#############*   ############
pattern = '\d*'
q = '123qwe'
w = '12345qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e) #   
print(q1,'
',w1,'
',e1)
#############+   ############
pattern = '\d+'
q = '123qwe'
w = '12345qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
print(q1,'
',w1,'
',e1)
#############{}   ############
pattern = '\d{2}'
pa1 = '\d{1,}'
q = '123qwe'
w = '1qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pa1,e)
q2 = re.match(pa1,q)
w2 = re.match(pa1,w)
e2 = re.match(pa1,e)
print(q1,'
',w1,'
',e1)
print(q2,'
',w2,'
',e2)


##################  #######################################
<re.Match object; span=(0, 3), match='123'> 
 <re.Match object; span=(0, 5), match='12345'> 
 <re.Match object; span=(0, 0), match=''>
<re.Match object; span=(0, 3), match='123'> 
 <re.Match object; span=(0, 5), match='12345'> 
 None
<re.Match object; span=(0, 2), match='12'> 
 None 
 None
<re.Match object; span=(0, 3), match='123'> 
 <re.Match object; span=(0, 1), match='1'> 
 None

Process finished with exit code 0

원본 문자열
정규 표현 식 에 서 는 '\' 를 이동 문자 로 사용 합 니 다.
Python 의 문자열 앞 에 r 를 붙 여 원생 문자열 을 표시 합 니 다.
예: 출력 경 로 를 사용 할 때 두 번 의 역 슬 래 쉬 를 사용 해 야 합 니 다.

import re
print('c:\\a\\c\\d')
s = '\\t123'
pattern = '\\\\t\d*'
o = re.match(pattern,s)
pa1 = r'\\t\d*'
o1 = re.match(pa1,s)
print(o,'
',o1)

############    #################################

c:\a\c\d
<re.Match object; span=(0, 5), match='\\t123'> 
 <re.Match object; span=(0, 5), match='\\t123'>

Process finished with exit code 0

경계 문자
문자
기능.
^
일치 문자열 시작
$
일치 문자열 끝
\b
단어 경계 일치
\B
단어 가 아 닌 경계 일치
예시

import re
#  QQ  ，  5,10 
# $   
a = '[email protected]'
b = '[email protected]'
pattern = '[1-9]\d{4,9}@qq.com'
pa1 = '[1-9]\d{4,9}@qq.com$'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'
',w1,'
',q2,'
',w2)
# ^   
a = 'hello world'
b = 'python'
pattern = 'hello.*'
pa1 = r'^hello.*'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'
',w1,'
',q2,'
',w2)
# \b   
a = '1234 abc'
b = '123 ab'
pattern = r'.*\bab'
pa1 = r'.*ab\b'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'
',w1,'
',q2,'
',w2)


#########################  ##########################
<re.Match object; span=(0, 13), match='[email protected]'> 
 <re.Match object; span=(0, 13), match='[email protected]'> 
 <re.Match object; span=(0, 13), match='[email protected]'> 
 None
<re.Match object; span=(0, 11), match='hello world'> 
 None 
 <re.Match object; span=(0, 11), match='hello world'> 
 None
<re.Match object; span=(0, 7), match='1234 ab'> 
 <re.Match object; span=(0, 6), match='123 ab'> 
 None 
 <re.Match object; span=(0, 6), match='123 ab'>

Process finished with exit code 0

패 킷
하나의 모드 에서 괄호 로 묶 은 부분 이 있 으 면 이 부분 은 그룹 으로 되 어 있 으 며, group 방법의 매개 변 수 를 통 해 지정 한 그룹 과 일치 하 는 문자열 을 가 져 올 수 있 습 니 다.
문자
기능.
（ab）
괄호 안에 있 는 문 자 를 그룹 으로 묶 습 니 다.
um
그룹 num 에 일치 하 는 문자열 참조
(?p)
각각 그룹 명 을 짓다
(?p=name)
name 그룹 에 일치 하 는 문자열 을 참조 합 니 다.
예시

import re
#         -     010-43222 0432-447721
#(ab)   
pa = '(\d{3,4})-([1-9]\d{4,7}$)'
s = '010-43222'
o = re.search(pa,s)
print(o.group())
print(o.group(1))
print(o.groups())
print(o.groups()[0])

#########################  #############################
010-43222
010
('010', '43222')
010

#
um   
pattern = r'.+\2>\1>'
s = 'head  '
s1 = '