python 3 의 정규 모듈

본문 인용: 정규 모듈
정규 와 가장 관련 된 것 은 문자열 이 라 고 할 수 있 지만 내 장 된 py 의 str 형식 에는 내 장 된 정규 방법 이 없습니다. str 의 기본 적 인 방법 을 살 펴 볼 수 있 습 니 다. 저 는 가장 유용 하 다 고 생각 합 니 다. find, len, split, join 이 네 가지 방법 이 라 고 할 수 있 습 니 다. 그러나 문자열 조작 에 있어 서 이것 은 정말 too simple 입 니 다. 그래서 py 는 우리 에 게 Re 모듈 을 제공 합 니 다.정규 문자열 을 사용 하여 관련 작업 을 할 수 있 도록 도 와 줍 니 다. 또한, py 의 정규 규칙 은 perl - like 이기 때문에 지원 하 는 정규 기능 은 js 보다 훨씬 많 습 니 다.
Re 사용
우선 정규 모듈 을 가 져 와 야 합 니 다.

import re

우 리 는 dir(re) 을 사용 하여 그 안에 주로 어떤 방법 이 있 는 지 볼 수 있 습 니 다. 또는 python 홈 페이지 를 직접 찾 아 볼 수 있 습 니 다. 그러면 우 리 는 관련 정규 방법 을 사용 할 수 있 습 니 다. 정식 사용 방법 전에 py 에 정규 규칙 을 쓰 는 것 을 배 워 야 합 니 다. py 는 다른 언어 // (slashes) 를 정규 식별 자로 사용 하 는 것 과 다 르 기 때문에 py 사용 r정규 표현 식 flag.

# js 
/\d+/
# py 
r"\d+"

다음은 re 모듈 을 소개 하 는 동시에 python 의 정규 문법 을 간단하게 설명 하 겠 습 니 다.
match
match 는 string 에서 pattern 에 일치 하 는 부분 을 찾 는 데 사 용 됩 니 다. 기본 syntax:
re.match(pattern, string, flags=0)

pattern: 정규 표현 식

string: 일치 하 는 문자열

flags: 정규 일치 하 는 모드 를 표시 합 니 다. 예 를 들 어 대소 문자 무시, 전역 일치 등

match 는 re 사용자 정의 match object 를 되 돌려 줍 니 다. 물론 일치 하지 않 으 면 None 으로 돌아 갑 니 다. demo 를 보 겠 습 니 다.

reg = re.match(r"\w", "wa");
#   flag: re.I ->      
reg = re.match(r"\w", "wa",re.I);

만약 일치 하 게 된다 면, 우 리 는 어떻게 안에서 우리 가 원 하 는 것 을 얻 을 수 있 습 니까?간단 합 니 다: match object 위 에 두 가지 방법 이 있 습 니 다: group 과 groups

group (num = 0): 일치 하 는 내용 을 되 돌려 줍 니 다. 0 모든 일치 하 는 내용 을 되 돌려 줍 니 다. 1 부터 (...) 를 통 해 일치 하 는 내용

을 되 돌려 줍 니 다.

groups (): (...) 를 통 해 일치 하 는 모든 하위 내용 을 되 돌려 주 고 tuple 에 넣 습 니 다.

reg = re.match(r"\w", "w1a",re.I);
print(reg.group(0)) #    w

reg = re.match(r"\b\w*\b(\s\b\w*\b)", "Cats are smarter than dogs");

print(reg.group(0)) # Cats are
print(reg.group(1)) # are
print(reg.groups()) # (' are',)

또 하나의 상용 방법 은 search 입 니 다. 현재 그 와 match 의 차이 가 어디 에 있 는 지 모 르 겠 습 니 다.
search
search 방법 은 첫 번 째 정규 에 맞 는 str 내용 을 찾 는 데 사 용 됩 니 다. 마찬가지 로 일치 하면 match Object 로 돌아 갑 니 다. 일치 하지 않 으 면 None 으로 돌아 갑 니 다. 따라서 그의 match 방법 은 위 와 같 습 니 다.
하지만 실제로는 차이 가 있다.공식 소개 에 따 르 면 match 는 string 의 시작 부분 부터 만 일치 할 수 있 고 search 는 모든 위치 에서 부터 일치 할 수 있 습 니 다. 다음 과 같 습 니 다.

match 기본 값 은 r"^xxxx" 소스 입 니 다.

search 는 javascript 의 /\w+/g 전역 과 유사 합 니 다.

구체 적 으로 demo 를 보 세 요.

search = re.search(r"123", "aresmarter12323handogs");
match = re.match(r"123", "aresmarter12323handogs")
print(search.group()) # Cats are
print(match.group()) # AttributeError

match 를 사용 하면 이 점 이 어색 합 니 다.
sub
이 방법 은 일치 하 는 str 부분 을 지정 한 문자열 로 대체 하 는 것 입 니 다. 실제로 python 의 replace 방법 과 같 습 니 다. 다만 그 는 정규 로 일치 하 는 것 입 니 다: syntax:
re.sub(pattern, repl, string, max=0)

pattern: 정규 표현 식

repl: replace 가 대체 할 문자열

string: 대상 문자열

max: 교체 횟수. 0 이면 기본적으로 교체 하지 않 고 1 이면 한 곳 을 교체 하 는 것 을 나타 낸다

예 를 들 어 똑똑히 보 세 요.

reg = re.sub(r"\d+","", "remove digital from xxx123xxx123xx");
print(reg) # remove digital from xxxxxxxx

reg = re.sub(r"\d+","", "remove digital from xxx123xxx123xx",1);
print(reg) # remove digital from xxxxxx123xx

compile
이것 은 python 이 제공 하 는 parse regexp 방법 함수 입 니 다. 사실은 더 좋 은 정규 를 재 활용 하기 위해 서 입 니 다. 예 를 들 어 저 는 정규 가 있 습 니 다. 하지만 여러 번 사용 하고 싶 으 면 copile 이 없 는 상태 에서 copy 만 할 수 있 습 니 다. 이것 은 실제 자바 script 의 RegExp 대상 과 일리 가 있 습 니 다. 그리고 이 방법 에 마 운 트 되 어 있 습 니 다. 모든 정규 에 의존 하 는 방법, 즉,pattern 을 입력 해 야 하 는 곳 은 dot 를 직접 사용 하여 호출 할 수 있 습 니 다. 기본 형식 은:
re.compile(pattern, flags=0)
데모 보 세 요.

getDigital = re.compile(r'\d+',re.I)
a_str = 'remove digital from xxxxxx123xx'
removeDigital = getDigital.sub('',a_str)
print(removeDigital) # remove digital from xxxxxxxx

상황 을 봐 서 쓰 세 요.
findall
위의 match 와 search 부터 필요 하 다 고 생각 합 니 다. findall 은 match 와 search 보다 이 방법 이 더 흔 하기 때 문 입 니 다. 사용 빈도 에 따라 정렬 할 수 있 습 니 다.

findall > search > match

findall 의 역할 은 전역 일치 입 니 다. 형식 은:
re.findall(pattern, string, flags=0)
그 가 돌아 온 내용 은 match object 가 아니 라 list 입 니 다. 전체 string 에서 pattern 에 맞 는 내용 을 표시 합 니 다. (match 와 차이 가 별로 없 음) demo 를 보 세 요.

get_digital = re.findall(r'\d+',"123 I am a space 13123")
print(get_digital) # ['123', '13123']

fullmatch
fullmatch 는 정규 와 string 이 완전히 일치 하 는 관 계 를 나타 내 는 데 사 용 됩 니 다. 처음부터 끝까지 일치 하면 관련 내용 을 되 돌려 줍 니 다. 그렇지 않 으 면 None. fullmatch 는 r"\A your regular expression \Z" 에 해당 합 니 다. ^ 대체 \A 를 사용 할 수 있 습 니 다. $ 대체 \Z 형식 은 다음 과 같 습 니 다.
fullmatch(pattern, string, flags=0)
데모 보기:

get_digital = re.fullmatch(r'\d{3,11}',"331213322")
same_effect = re.match(r'^\d{3,11}$',"331213322")
print(get_digital.group()) #   fullmatch
print(same_effect.group()) #   \A \Z     

split
str 의 split 방법 에 비해 그의 역할 은 정규 와 일치 하 는 것 입 니 다. 돌아 오 는 것 은 list 입 니 다. 형식 은:
split(pattern, string, maxsplit=0, flags=0)
데모 보 세 요.

split_str = re.split(r'\d','this is 1 this is 2')
print(split_str) # ['this is ', ' this is ', '']

마지막 으로 에 스 케 이 프 방법 을 소개 합 니 다. 악성 문 자 를 처리 하 는 데 자주 사 용 됩 니 다.
escape
다른 문 자 를 걸 러 내 는 데 사용 할 때 ASCII 와 숫자 만 유지 합 니 다. (v 3.3 버 전에 서 지원 _ 하지만 지금 은 지원 되 지 않 습 니 다.) 그의 반환 값 은 새로운 str 입 니 다. 형식 은:
escape(string)
데모 보기:

esc = re.escape('I"m a evil  window.location.href="villainhr.com"')
print(esc) #            \     .
# I\"m\ a\ evil\ \\ window\.location\.href\=\"villainhr\.com\"\<\/script\></code></pre> 
 <p>         ,         , match object              .</p> 
 <h2>Match Object</h2> 
 <p>match object  match   search      .      , MO(match object)           , group()    groups().       ,        , MO             。</p> 
 <ul> 
  <li><p>start([group]):     group  str      .     Number。</p></li> 
 </ul> 
 <pre><code>reg = re.match(r"\w+\d+(\w+)", "first1232second");
print(reg.group(1),'start from',reg.start(1)) # second start from 9</code></pre> 
 <ul> 
  <li><p>end([group]):  start   ,     group     .</p></li> 
 </ul> 
 <pre><code>reg = re.match(r"\w+\d+(\w+)", "first1232second");
print(reg.group(1),'end up with',reg.end(1)) # second end up with 15</code></pre> 
 <p>         start end           .</p> 
 <ul> 
  <li> 
   <ul> 
    <li><p>            :(  ,       index 2,index 1         )</p></li> 
   </ul></li> 
 </ul> 
 <pre><code>exa = "first1232second third"
reg = re.search(r"\d+(\w+)\s(\w+)", exa);
print(exa[:reg.start(2)]) # first1232second </code></pre> 
 <ul> 
  <li> 
   <ul> 
    <li><p>                  :</p></li> 
   </ul></li> 
 </ul> 
 <pre><code>exa = "first1232second , third"
reg = re.search(r"\d+(\w+)\s[/'',.]\s(\w+)", exa);
print(exa[reg.end(1):reg.start(2)]) #  , </code></pre> 
 <p>   ,           .</p> 
 <ul> 
  <li><p>span([group]):     group    str     .</p></li> 
 </ul> 
 <pre><code>reg = re.match(r"\w+\d+(\w+)", "first1232second");
print(reg.group(1),'its span is',reg.span(1)) #   
# second its span is (9, 15)</code></pre> 
 <ul> 
  <li><p>lastindex:          index.          ,    None. lastindex                  (   +1    )</p></li> 
 </ul> 
 <pre><code>reg = re.search(r"\d+(\w+)", "first1232second");
print(reg.lastindex) #    1</code></pre> 
 <ul> 
  <li><p>lastgroup:            .         ,      .          demo:</p></li> 
 </ul> 
 <pre><code>exa = "first1232second , third third"
reg = re.search(r"\d+(?P<name>\w+)\s[/'',.]\s(?P<sam>\w+)\s", exa);
print(reg.lastgroup) # sam</code></pre> 
 <p> python ,       (?P< xxx>)       .    , lastgroup      ,       .<br>   ,   re   ,  MO              .</p> 
 <p>         ,  flags        (  group)</p> 
 <h2>regexp supplement</h2> 
 <h3>     </h3> 
 <p>         ,           ,          x .               ,   sub  ,    group   .</p> 
 <p>  ,        group   .<br>      <code>
umber</code>       ,            <code>(?P<xxx>)</code>。       ,      group  ,              . <br>Old style:</p> 
 <pre><code>exa = "first1232second , third"
reg = re.search(r"\d+(\w+)", exa);
print(reg.group(1))</code></pre> 
 <p>      1  ,   ,         ,    group(0)              .<br>         ,  group     . <br>New style:</p> 
 <pre><code>exa = "my id is 12334213"
reg = re.search(r"(?P<id>\d+)", exa);
print(reg.group('id'))</code></pre> 
 <p>            ,     ,     .     .</p> 
 <p>          ,    sub  ,       HTML  .<br>   demo :</p> 
 <pre><code>exa = '<text top="33" font="0"><b>test</b></text>'
new_text = re.sub(r"<b>(.*?)</b>", r'\1',exa);
print(new_text)</code></pre> 
 <p>  ,              :</p> 
 <pre><code>exa = '<text top="33" font="0"><b>test</b></text>'
new_text = re.sub(r"<b>(?P<innerHTML>.*?)</b>", r'\g<innerHTML>',exa);
print(new_text)</code></pre> 
 <p>        .</p> 
 <p>  ,          re       flag</p> 
 <h3>flag</h3> 
 <p>            :</p> 
 <table> 
  <thead> 
   <tr> 
    <th align="left">name</th> 
    <th align="left">effect</th> 
   </tr> 
  </thead> 
  <tbody> 
   <tr> 
    <td align="left">re.I</td> 
    <td align="left">       </td> 
   </tr> 
   <tr> 
    <td align="left">re.M</td> 
    <td align="left">    .      ,<code>^</code> <code>$</code>   str        ,           .    re.M flag  ,      ,  str       <code>^...$</code>         </td> 
   </tr> 
   <tr> 
    <td align="left">re.S</td> 
    <td align="left"> flag     <code>.</code>    .   <code>.</code>         ,       .  ,       flag ,   <code>.</code>         </td> 
   </tr> 
   <tr> 
    <td align="left">re.X</td> 
    <td align="left">        regexp.            ,      comment    ,    ,        .   ,regexp        ,       <code>\s</code> </td> 
   </tr> 
  </tbody> 
 </table> 
 <p>       demo,       re.X   .</p> 
 <pre><code>a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
# a    b</code></pre> 
 <p> demo,          .</p> 
 <p>             ,           .</p> 
 <p><span class="img-wrap"></span></p> 
</div>
                            </div>
                        </div>
                    </div>
                    <!--PC WAP    -->
                    <div id="SOHUCS" sid="1175672698227994624"></div>
                    <script type="text/javascript" src="/views/front/js/chanyan.js">