re 모듈 상세 설명

정규 표현 식 특수 문자 소개

^                                                   
$                                                   
.                                     
[]                        
[^]                          
[-]                      
？                1   0 
+                 1     
*                 0     
{n}               n 
{m,n}              n ，  m 
{n,}               n 
|               |  |    
(...)             

\A       ^    ，        
\Z          ， $
\d        0-9
\D         
\w      [A-Za-z0-9]
\W       [A-Za-z0-9]
\s           、\t、
、\r
(?P...)        
  ：?P       

 
re 모듈 방법 소개
1. 클래스 매 칭 방법
a. findall 방법

 findall  ，              ，                 ，                ，         ，
#              ，            ，  ，      ，         findall          ，     
#       ，          ，        

 

# re.findall()                
 
re_str = "hello this is python 2.7.13 and python 3.4.5"
 
pattern = "python [0-9]\.[0-9]\.[0-9]"
res = re.findall(pattern=pattern,string=re_str)
print(res)
 
# ['python 2.7.1', 'python 3.4.5']
 
pattern = "python [0-9]\.[0-9]\.[0-9]{2,}"
res = re.findall(pattern=pattern,string=re_str)
print(res)
 
# ['python 2.7.13']
 
 
pattern = "python[0-9]\.[0-9]\.[0-9]{2,}"
res = re.findall(pattern=pattern,string=re_str)
print(res)
 
# []
 
# re.findall()   ，      ，       ，               ，       ，         
 
re_str = "hello this is python 2.7.13 and Python 3.4.5"
 
pattern = "python [0-9]\.[0-9]\.[0-9]"
res = re.findall(pattern=pattern,string=re_str,flags=re.IGNORECASE)
print(res)
 
# ['python 2.7.1', 'Python 3.4.5']
 
#     flags=re.IGNORECASE，        

b. 정규 표현 식 을 컴 파일 하 는 방식 으로 사용 합 니 다.

#              python     ，          ，                ，             
re_str = "hello this is python 2.7.13 and Python 3.4.5"
re_obj = re.compile(pattern = "python [0-9]\.[0-9]\.[0-9]",flags=re.IGNORECASE)
res = re_obj.findall(re_str)
print(res)

c. match 방법

# match  ，        startwith  ，  match             ，      ，match              ，    
#     ，    SRE_Match     ，        ，     None，           ，       startwith    ，   
#     data      what        

 

s_true = "what is a boy"
s_false = "What is a boy"
re_obj = re.compile("what")
 
print(re_obj.match(string=s_true))
# <_sre.sre_match object="" span="(0," match="what" print="" none="" s_true="123what is a boy" s_false="what is a boy" re_obj="re.compile("\d+")">
 
print(re_obj.match(s_true).start())
# 0
print(re_obj.match(s_true).end())
# 3
print(re_obj.match(s_true).string)
# 123what is a boy
print(re_obj.match(s_true).group())
# 123
 
 
print(re_obj.match(s_false))
# None

d, 검색 방법

# search  ，       ，      SRE_Match  ，search   match       match        ， search   
#             ，       ，      ，    SRE_Match  ，      ，    None，      ，
# search         ，                   ，             ，          ，   
#      findall  ，     finditer  

e, finditer 방법

# finditer       ，           SRE_Match  ，       

 

re_str = "what is a different between python 2.7.14 and python 3.5.4"
 
re_obj = re.compile("\d{1,}\.\d{1,}\.\d{1,}")
 
for i in re_obj.finditer(re_str):
    print(i)
 
# <_sre.sre_match object="" span="(35," match="2.7.14">
# <_sre.sre_match object="" span="(53," match="3.5.4">

 
2. 수정 유형 방법 소개
a, sub 방법

# re  sub          replace  ，  sub           ，  ，re   sub          

 

re_str = "what is a different between python 2.7.14 and python 3.5.4"
 
re_obj = re.compile("\d{1,}\.\d{1,}\.\d{1,}")
 
print(re_obj.sub("a.b.c",re_str,count=1))
# what is a different between python a.b.c and python 3.5.4
 
print(re_obj.sub("a.b.c",re_str,count=2))
# what is a different between python a.b.c and python a.b.c
 
print(re_obj.sub("a.b.c",re_str))
# what is a different between python a.b.c and python a.b.c

b. split 방법

# re   split   python     split        ，                  ，    re   split    
#        
#        ，  .    : !     ，        

 

re_str = "what is a different between python 2.7.14 and python 3.5.4 USA:NewYork!Zidan.FRA"
 
re_obj = re.compile("[. :!]")
 
print(re_obj.split(re_str))
# ['what', 'is', 'a', 'different', 'between', 'python', '2', '7', '14', 'and', 'python', '3', '5', '4', 'USA', 'NewYork', 'Zidan', 'FRA']

c. 대소 문자 민감 하지 않 은 설정

# 3、      
 
# re.compile(flags=re.IGNORECASE)

d. 탐욕 이 아 닌 일치

# 4、     ，                 ，   ，                 ，               ？  
 
#      ，    .
s = "Beautiful is better than ugly.Explicit is better than impliciy."
 
 
re_obj = re.compile("Beautiful.*y\.")
 
print(re_obj.findall(s))
# ['Beautiful is better than ugly.Explicit is better than implicit.']
 
re_obj = re.compile("Beautiful.*?\.")
 
print(re_obj.findall(s))
# ['Beautiful is better than ugly.']

e. 정규 일치 문자열 에 작은 괄호 를 넣 으 면 어떤 효과 가 있 습 니까?
진정한 작은 괄호 를 설정 하려 면 전의 자가 필요 합 니 다. 아래 의 예 를 자세히 보 세 요. search 방법 으로 돌아 오 는 대상 의 group (1) 이 방법 은 잘못 보 고 된 것 입 니 다.

import re
s = "=aa1239d&&& 0a ()--"
 
# obj = re.compile("\(\)")
# search
# rep = obj.search(s)
# print(rep)
# <_sre.sre_match object="" span="(15," match="()">
# print(rep.group(1))
# IndexError: no such group
# print(rep.group())
# ()

# findall
 
rep = obj.findall(s)
print(rep)
# ['()']

괄호 에 일치 하 는 문자열 을 되 돌려 주 려 면 이 작은 괄호 는 전의 문자 가 필요 없습니다. findall 방법 은 젊은이 들 이 잘 어 울 리 는 문자열 을 되 돌려 줍 니 다. search. group () 방법의 전체 패턴 은 문자열 과 일치 합 니 다. search. group (1) 이것 은 첫 번 째 작은 괄호 에 일치 하 는 패턴 과 일치 하 는 문자열 입 니 다. search. group (2)이것 은 두 번 째 작은 괄호 의 패턴 과 일치 하 는 문자열 입 니 다.

s = "=aa1239d&&& 0a ()--"
rep = re.compile("\w+(&+)")
 
print(rep.findall(s))
# ['&&&']
print(rep.search(s).group())
# aa1239d&&&
print(rep.search(s).group(1))
# &&&

 
다음으로 전송: https://www.cnblogs.com/bainianminguo/p/10657631.html