정규식(정규)

Regular(regular), 정규식을 사용하려면 Python에서 re(regular의 약어) 모듈을 import해야 합니다. 정규식은 문자열을 처리하는 데 사용됩니다. 문자열에는 추출하려는 많은 정보가 포함되어 있는 경우가 있습니다. 이러한 문자열 처리 방법을 익히면 많은 작업이 쉬워집니다.

정규 표현식(regular), 문자열을 처리하는 방법입니다. http://www.cnblogs.com/alex3714/articles/5169958.html

파일 처리가 Python에서 매우 일반적이기 때문에 정규 표현식이 일반적인 방법입니다. 파일에 문자열을 처리하려면 다음을 수행하십시오. 정규식을 사용해야 합니다. 그러므로 정규식을 마스터해야 합니다. 정규식에 포함된 메서드를 살펴보겠습니다.

(1) match(pattern, string, flags=0)

def match(pattern, string, flags= 0):
　　　"""문자열 시작 부분에 패턴을 적용해 보세요.
　　 일치 개체를 반환하거나, 일치 항목이 없으면 None을 반환합니다."""
　　　return _compile(pattern, flags).match (string)

위의 설명: 문자열 시작 부분에 패턴을 적용하여 일치 객체를 반환하거나, 일치 항목이 없으면 None을 문자열 시작 부분에서 검색해 보세요. 일치 개체를 반환하거나, 찾을 수 없으면 None을 반환합니다.

핵심 사항: (1) 처음부터 검색을 시작합니다. (2) 찾을 수 없으면 None을 반환합니다.

몇 가지 예를 살펴보겠습니다.

import re
string = "abcdef"
m = re.match("abc",string) (1) "abc"를 일치시키고 확인합니다. 반환된 결과는 무엇입니까? print(m)
print(m.group()) n = re.match(
"abcf",string)
print(n) (2) 문자열이 목록에 없습니다. 상황
　l = re.match(
"bcd",string) (3) 리스트 중간에 문자열 검색 상황
　print(l)

실행 결과 ：

<_sre.SRE_Match object;span=(0, 3), match='abc'> （1)abc （2) ）

　None                                

위의 출력 결과 (1)에서 match()를 사용하여 일치 개체 개체를 반환하는 것을 볼 수 있습니다. 보이는 상황으로 변환하려면 그림과 같이 group()을 사용하여 변환해야 합니다. in (2); 일치하는 정규식이 문자열에 없으면 None (3)이 반환됩니다. match(pattern, string, flag)는 문자열의 시작 부분부터 일치하며 문자열의 시작 부분에서만 일치할 수 있습니다. 4) 표시됩니다.

(2) fullMatch (패턴, 문자열, 플래그 = 0)

def fullMatch (패턴, 문자열, 플래그 =
0) :
"" "" 패턴을 모든 문자열에 적용하여 일치 개체를 반환
                        일치 항목을 찾지 못한 경우 None을 반환합니다. 위의 설명: 모든 문자열에 패턴을 적용하고 일치 항목을 반환하거나 일치 항목을 찾지 못한 경우 None을 시도해 보세요. .. (3) 검색(패턴, 문자열, 플래그)

    def 검색(패턴, 문자열, 플래그=

0):

   　　　　"""문자열 검색 ~을 찾고 있다 패턴과 일치하여    　　　　일치 개체를 반환하거나, 일치하는 항목이 없으면 None을 반환합니다."" "                                                                    return _compile(pattern, flags).search(string)

         검색 코멘트(pattern , 문자열, 플래그)는 문자열을 통해 패턴과 일치하는 항목을 찾고, 일치 개체를 반환하며, 일치 항목이 없으면 None을 반환합니다. 문자열의 임의 위치에서 정규식을 검색하면 일치 개체 개체를 반환합니다. . 찾을 수 없으면 None을 반환합니다.

핵심 사항: (1) 처음부터 검색하는 match()와 달리 문자열 중간에서 검색합니다. (2) 검색을 찾을 수 없으면 None이 반환됩니다. import re String =
"ddafsadadfadfafdafdadfasfdafafda"　m = re.search("a",string) (1) 중간부터 일치print(m)

print(m.group())

n = re.search ("N",string) (2) 일치하지 않는 상황

print(n)




실행 결과는 다음과 같습니다.


< _sre .SRE_Match 개체; 범위 =(2, 3), match='a'> (1)　a (3)

위의 결과(1)에서 알 수 있듯이 search(pattern, string, flag=0)는 가운데 어느 위치에서나 일치할 수 있으며, 이는 match()와 달리 다음 위치에서만 일치할 수 있다는 것을 알 수 있습니다. 일치에 도달하면 반환됩니다. (2) match_object 개체를 표시하려면 group() 메서드를 사용해야 합니다. (3) 찾을 수 없으면 반환됩니다. 없음.

(4) sub(pattern,repl,string,count=0,flags=0)

def sub(pattern, repl, string, count=0, flags=0 ):
　　"""문자열에서 가장 왼쪽
　　겹치지 않는 패턴을
　　　대체 repl로 대체하여 얻은 문자열을 반환합니다. repl은 문자열이거나 호출 가능일 수 있습니다.
　　문자열인 경우, 백슬래시 이스케이프가 호출 가능한 경우
일치 개체가 전달되고
사용할 대체 문자열을 반환해야 합니다.
sub(pattern,repl,string,count=0,flags=0) 검색 및 바꾸기, 즉 검색을 먼저 수행합니다. 패턴이 문자열에 있는지 여부는 문자열입니다. 패턴과 일치하려면 정규식으로 찾은 문자를 바꿔야 합니다. count는 일치 항목 수와 일치 항목 수를 지정할 수 있습니다. 예시는 다음과 같습니다. import re　 string = "ddafsadadfadfafdafdadfasfdafafda"　m = re.sub("a","A",string) #개수는 지정하지 마세요. replacements ( 1)

　print(m)　n = re.sub(

"a",

"A",string,2) #
대체 횟수 지정 (2)
　print(n)
　l = re.sub("F","B",string) #일치 없음(3)
　print(l)





실행 결과는 다음과 같습니다. ddAfsAdfAdfAfdAfdAdfAsfdAfAfdA --(1) ddAfsAdadfadfafdafdadfasfdafafda -- (2) 　 ddafsadadfadfafdafd adfasfdafafda --(3) 위 코드 (1)은 숫자를 지정하지 않습니다. 기본값은 모든 항목을 일치시키는 것입니다. 일치 항목 수가 (2)에 지정된 경우 (3)에 일치할 일반 패턴이 문자열에 없으면 지정된 숫자만 일치합니다. 원래 문자열이 반환됩니다.

    큼: (1) 可以指定匹配个数, 不指定匹配所有; (2)如果匹配不到会返回原来的字符串;

    （5)subn(패턴,반복,문자열,개수 =0,flags=0)

    def subn(pattern, repl, string, count=0, flags=0):
   　　　　"""(new_string, number)를 포함하는 2-튜플을 반환합니다. .
   　　　　new_string은 소스
   　　　　문자열에서 가장 왼쪽
   　　　　겹치지 않는 패턴을 교체하여 얻은 문자열입니다. 　　　　repl은 문자열일 수 있습니다. 또는 a
   　　　　호출 가능한 문자열인 경우 백슬래시 이스케이프가 처리됩니다.
   　　　　호출 가능한 경우 일치 개체를 전달하고
   　　　　사용할 대체 문자열을 반환해야 합니다."""
   　　　　
return _compile (pattern, flags).subn(repl, string, count)

    上面注释(new_string,number)을 포함하는 2-튜플을 반환합니다.个원组,用于存放正则匹配の后的新字符串和匹配的个数(new_string,number)。

   

import re　　string = "ddafsadadfadfafdafdadfasfdafafda"

　　m = re.subn("a",
"A",string)     #전체부替换的情况 （1）　　print(m)
　　n = re.subn(
"a",
"A",string,3)    # ㅋㅋㅋ 에서   （3） 　　print(l)



    运行结果如下：    ('ddAfsAdAdfAdfAfdAfdAdfAsfdAfAfdA', 11)     （ 1)　　('ddAfsAdAdfadfafdafdadfasfdafafda', 3)      （2)　　('ddafsadadfadfafdafdafdadfasfdafafda', 0)       （3)

위 코드의 출력에서 ​​sub()와 subn(pattern,repl,string,count=0,flags=0)이 동일한 일치 효과를 가지지만 반환되는 결과가 다르다는 것을 알 수 있습니다. sub()는 여전히 문자열을 반환하고 subn()은 정규식과 대체 횟수 뒤에 새 문자열을 저장하는 데 사용되는 튜플을 반환합니다.

（6）split(pattern,string,maxsplit=0,flags=0)

def Split(pattern, string, maxsplit=0, flags=0):
　 """패턴 발생 횟수로 소스 문자열을 분할합니다.
            결과 하위 문자열을 포함하는 목록을 반환합니다. 결과
          목록. maxsplit이 0이 아닌 경우 최대 maxsplit 분할이 발생합니다.
            및 문자열의 나머지 부분 마지막 요소로 반환됩니다.                   s ).split(string, maxsplit)



Split(pattern, string, maxsplit=0, flags=0)은 분할입니다. 특정 정규 요구 사항 패턴에 따라 문자열을 분할하고 결과 하위 문자열이 포함된 목록을 반환한다는 것은 문자열을 어떤 방식으로 분할하여 목록에 배치하는 것을 의미합니다. 예는 다음과 같습니다. import re String =

"ddafsadadfadfafdafdadfasfdafafda"

m = re.split(

"a",string)

#문자열 분할(1
）
　인쇄( m)
　n = re.split("a",string,3) #분할 개수 지정
　print(n)
　l = re.split(
"F",string) #분할 문자 문자열이 목록에 없습니다　print(l)



다음과 같습니다: ['dd', 'fs', 'd', 'df', 'df', 'fd', 'fd', 'df', 'sfd', 'f', 'fd', ''] （ 1)　['dd', 'fs', 'd', 'dfadfafdafdadfasfdafafafda']                                          (3)

(1)에서 볼 수 있듯이 문자열의 시작이나 끝 부분에 나눌 문자열이 포함되어 있으면 다음 요소는 ""가 됩니다. (2)에서 나눌 횟수를 지정할 수 있습니다. at (3) if 분할된 문자열이 목록에 없으면 원래 문자열이 목록에 배치됩니다.

（7)findall(pattern,string,flags=)

def findall(pattern, string, flags=0):
　　"""모든 비-목록 반환 문자열에 일치 항목이 겹칩니다.

패턴에 하나 이상의 캡처 그룹이 있는 경우 그룹 목록을 반환합니다. 패턴에 그룹이 두 개 이상 있으면 튜플 목록이 됩니다.​ ​pattern,string ,flags=)Yes 일치하는 모든 요소를 ​​포함하는 목록을 반환합니다. 목록에 저장됩니다. 예는 다음과 같습니다:


import re　 string =
"dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"
　m = re.findall( "[ a-z]",string) #문자 일치, 모든 문자 일치, 목록 반환( 1)
　print(m)　n = re.findall("[0-9]",string) 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 통과(m) | ("[ABC]",문자열)                                                                                                                      다음과 같습니다. ['d', 'd', 'a', 'd', 'f', 'a', 'd', 'f', 'a', 'f', 'd', 'a', ' f', 'd', 'a', 'd', 'f', 'a', 's', 'f', 'd', 'a', 'f', 'a', 'f' , 'd' , 'a']                                                                           ['1', '2', '3', '2',  '4', '6',  '4' ' 6', '5',  '1', '6', '4', '8', '1', '5', '6', '4', '1', '2', '7', '1', '1', '3 ', '0', '0', '2', '5', '8'] (2) [] (3)

위 코드의 결과는 (1) 모든 문자열과 일치합니다. 일치; 문자열의 숫자가 (2)에서 일치하면 목록이 반환되고, (3)에서 일치하는 숫자가 없으면 빈 목록이 반환됩니다.

핵심 사항: (1) 일치하는 항목이 없으면 빈 목록이 반환됩니다. (2) 일치하는 항목 수가 지정되지 않으면 단일 일치 항목만 만들어집니다.

    （8）finditer(pattern,string,flags=0)

    def finditer(pattern, string, flags=0):
   　　　　"""반환 겹치지 않는 모든 것에 대한 erator
   　　　　문자열에서 일치합니다.   각 일치 항목에 대해 반복자는 일치 개체를 반환합니다.

   　　　　빈 일치 항목이 결과에 포함됩니다."""
   　　　　return _compile(pat tern, 플래그).finditer(문자열)

    finditer(pattern,string)查找模式，문자열에서 겹치지 않는 모든 일치 항목에 대해 반복자를 반환합니다. 각 일치 항목에 대해 반복자는 일치 개체입니다.

    代码如下：

    import re
　　string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"

　　m = re.finditer("[a- z]",string)
　　print(m)

　　n = re.finditer("AB", string)
　　print(n)   

    运行结果如下：

               （1)
　　           （2）

    从上面运行结果可以看出，finditer(pattern,string,flags=0)返回的是一个iterator对象。

    （9)컴파일(패턴 n,플래그=0)

    def compile(pattern, flags=0):
   　　　　"정규식 패턴을 컴파일하여 패턴 개체를 반환합니다."
   　　　　return _compile(pattern, 플래그)

    （10）pruge()

    def purge():
   　　　　"정규식 캐시 지우기"
   　　　　_cache .clear()
   　　　　_cache_repl.clear() 

    （11)template(pattern,flags=0)

    def template(pattern, flags=0):
   　　　　"템플릿 패턴을 컴파일하여 패턴 개체 반환"
 　　　　return _compile( 패턴, 플래그|T)
    正则表达式：

    语法： 

　import re
　 String = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"

　p = re.compile("[a-z]+") #comp 파일을 먼저 사용하세요(pat tern) 컴파일
　m = p.match(string)                                                            일치
　print(m.group())

위의 2행과 3행을 한 줄로 결합하여 다음과 같이 작성할 수도 있습니다.

m <code class="python 키워드">= p.match("^[0- 9] ",'14534Abc'    m = p.match("^[0-9]",'14534Abc'<span style="font-family: 宋体">)</span> )

code>

효과는 같지만 차이점은 먼저 일치할 형식을 미리 컴파일해두는 것(일치하는 수식을 파싱)

이므로 굳이 할 필요가 없다. 다시 일치할 때 일치 형식을 컴파일할 때 두 번째 약어는 일치할 때마다 일치 수식을 한 번 컴파일해야 한다는 것입니다. 따라서 50,000줄이 있는 파일에서 숫자로 시작하는 모든 줄을 일치시켜야 하는 경우입니다. 먼저 정규식을 컴파일하는 것이 좋습니다. 수식이 컴파일된 후 일치되므로 속도가 빨라집니다.

일치 형식:

(1)^ 문자열의 시작 부분과 일치

import re
　 string = "dd12a32d41648f27fd1 1a0sfdda"
　#^의 시작 부분과 일치합니다. string, 이제
search()를 사용하여 일치시킵니다. 　m = re.search("^[0-9]",string)
#숫자로 시작하는 문자열 일치                   (1)

 print( m) 　n = re.search("^[a-z]+",string) #문자로 시작하는 문자열이 처음부터 일치하면
search()와 크게 다르지 않습니다. ) 　print(n.group())

실행 결과는 다음과 같습니다.

없음

　dd

위의 (1)에서는 ^를 사용하여 문자열의 시작 부분부터 일치를 시작하고, 문자열 앞에 숫자가 아닌 문자가 오기 때문에 일치가 실패하고 None이 반환됩니다. (2), 시작이 문자이고, 일치가 정확하며, 이렇게 보면 올바른 결과가 반환되기 때문에 문자로 일치를 시작합니다. ^는 처음부터 시작하는 match()와 실제로 유사합니다.

(2)$ 문자열의 끝과 일치

🎜🎜

import re
　 string = "15111252598"

　 #^ 문자열의 시작 부분을 일치시킵니다. 이제 search()를 사용하여 숫자로 시작하는
을 일치시킵니다. m = re.match(" ^[ 0-9]{11}$",string)
　print(m.group())

실행 결과는 다음과 같습니다.

15111252598

re. match("^[0-9]{11}$",string)의 의미는 숫자로 시작하고 길이가 11이며 숫자로 끝나는 형식을 일치시키는 것입니다.

(3) 점(·)은 줄바꿈을 제외한 모든 문자와 일치합니다. RE.Dotall 표시를 지정하면 행 변경이 포함된 모든 문자와 일치할 수 있습니다. 줄바꿈을 제외한 모든 문자와 일치합니다. 　m = re.match(".",string) #dot

(·)

숫자가 지정되지 않은 경우 단일 문자와 일치합니다. (1)　print( m.group())
　n = re.match(".+",string) #.+
개행 문자를 제외한 여러 문자와 일치합니다. (2)
print(n.group())





결과는 1　1511 위의 코드 실행 결과에서 (1) 점 (·)이 (2)의 모든 문자와 일치한다는 것을 알 수 있지만 이후에는 모든 문자와 일치합니다. 문자열에 공백이 포함되어 있고 결과는 문자열의 개행 문자 앞의 내용과만 일치하며 다음 내용은 일치하지 않습니다. 핵심 사항: (1) 점(·)은 개행 문자를 제외한 모든 문자와 일치합니다. (2) .+는 개행 문자를 제외한 여러 문자와 일치할 수 있습니다. (4) [...] 예를 들어 [abc]는 "a", "b" 또는 "c"와 일치합니다.

[object]는 대괄호에 포함된 문자와 일치합니다. [A-Za-z0-9]는 A-Z, a-z 또는 0-9와 일치함을 의미합니다.

import re
　 string = "1511n125dadfadf2598"

　 #[]대괄호에 포함된 문자 일치
　m = re.findall("[5fd]",string) #경기 5,f,d
문자열 print(m)

실행 결과는 다음과 같습니다:

['5', '5', 'd', 'd', 'f', 'd', 'f', '5']

위 코드에서는 문자열의 5, f, d를 일치시키고 목록을 반환하려고 합니다.

(5) [^...] [^abc] abc를 제외한 모든 문자와 일치

import re
　 string = "1511n125dadfadf2598"

　　# [^] 괄호 안에 포함된 문자 일치
　m = re.findall("[^5fd]",string) #문자열에서 5, f, d
　print(m)를 제외한 문자 일치

다음과 같이 실행합니다:

['1', '1', '1', 'n', '1', '2', 'a', ' a', '2', '9', '8']

위 코드에서는 5, f, d 이외의 문자를 일치시키고, [^]는 대괄호 문자 안의 문자 이외의 문자를 일치시킵니다.

(6)* 0개 이상의 표현식과 일치

import re
　string = "1511n125dadfadf2598"

　#* 는 0 또는 여러 표현
　m과 일치합니다. = re.findall("d*",string) #0개 이상의 숫자 일치
　print(m)

실행 결과는 다음과 같습니다:

['1511', '', '125', '', '', '', '', '', '', '', '2598' , '']

위의 실행 결과에서 볼 수 있듯이 (*)는 0개 이상의 문자와 일치하는 표현식입니다. 일치하는 항목이 0개 이상의 숫자인 경우 반환 값이 비어 있음을 알 수 있습니다. , 마지막으로 반환된 위치는 비어 있습니다(""). # (

+

)는 일치합니다 1 표현식　m = re.findall("d+",string)

#

일치 1또는 더 많은 숫자
　print(m)



다음과 같이 실행합니다: ['1511', '125', '2598'] 추가( +)는 하나 이상의 표현식과 일치합니다. 위의 d+는 하나 이상의 숫자와 일치하는 표현식입니다. 그리고 적어도 하나의 숫자와 일치합니다. (8)? 0 또는 1 표현식과 일치하며 탐욕스럽지 않습니다.

import re　 string =

"1511

n125dadfadf2598"

　　#(

?

)은 0 또는 1과 일치하는 표현식

　m = re.findall(

"d?",string) #은
0 또는 1
표현식과 일치합니다.print (m)


실행 결과는 다음과 같습니다.  ['1', '5', '1 ', '1', ' ', '1', '2', '5', '', '', '', '', '', '', '', '2', '5', '9' , '8' , ''] 위의 물음표(?)는 0 또는 1개의 표현식과 일치하는 것이고, 위는 0 또는 1개의 표현식과 일치하는 것입니다. 일치하는 항목이 없으면 빈("")이 반환됩니다.

(9) {n} n 번 일치, 문자열이 일치하는 횟수 정의

(10) {n,m} n 대 m 식 일치

(11) w 문자 및 숫자와 일치

w 문자열의 문자 및 숫자와 일치하며 코드는 다음과 같습니다.

import re
String = "1511n125dadfadf2598"

　　#( ? )은 0 또는 1
　 m = re.findall("w",string) #과 일치하는 표현식입니다. 0 또는 1print(m)

다음과 같이 실행됩니다.

 ['1', '5', '1 ', '1', '1' , '2', '5', 'd', 'a', 'd', 'f', 'a', 'd', 'f', '2', '5', '9', ' 8']

위 코드에서 볼 수 있듯이 w는 문자열의 영숫자 문자를 일치시키는 데 사용됩니다. 문자와 숫자를 일치시키기 위해 정규식을 사용합니다.

(12) W 대문자 W는 문자가 아닌 숫자와 일치하는 데 사용되며 이는 소문자 w

예는 다음과 같습니다.

import re 문자열 = "1511
n125dadfadf2598"
　　#W
문자열이 아닌 문자와 숫자를 일치시키는 데 사용됩니다　m = re.findall("W",string)
#W비문자와 일치하는 데 사용됩니다. 문자열의 문자와 숫자 Number　print(m)

다음과 같이 실행됩니다.

['n']

위 코드에서, W는 문자가 아닌 문자와 숫자를 일치시키는 데 사용되며 결과적으로 개행 문자가 일치됩니다.

(13)s 모든 공백 문자와 일치하며 [ntf]와 동일합니다.

예시는 다음과 같습니다:

import re
　 string = "1511n125dtardffadf2598"

　 #s는 일치하는 데 사용됩니다. 문자열 [ntrf]
　m = re.findall("s",string) #s에 해당하는 공백 문자는 문자열
　print(m)에 있는 공백 문자와 일치하는 데 사용됩니다. 　

다음과 같이 실행합니다.

['n', 't', 'r', 'x0c']

달리기 결과 위의 코드는 다음과 같습니다: s는 빈 문자와 일치하는 데 사용됩니다. 우리는 빈 문자와 일치합니다.

(14) S는 비어 있지 않은 문자와 일치합니다.

예는 다음과 같습니다. :

import re
　 string = "1511n125dtardffadf2598"

　 #S 는 비어 있지 않은 문자
　m과 일치하는 데 사용됩니다. = re.findall("S" , string) #S은 비어 있지 않은 문자
　print(m) 　

다음과 같이 실행됩니다:

['1', '5', '1', '1', '1', '2', '5', 'd', 'a', ' d', 'f', 'a', 'd', 'f', '2', '5', '9', '8']

위 코드에서 알 수 있듯이 S는 비어 있지 않은 문자를 일치시키는 데 사용되었습니다. 결과적으로 비어 있지 않은 문자와 일치했습니다.

(15) d [0-9]

(16) D 숫자가 아닌 모든 숫자와 일치

🎜 요약: findall(), Split( ) generate 그것들은 모두 목록이며, 하나는 특정 문자를 구분 기호로 사용하고 다른 하나는 검색의 모든 값을 사용합니다. 정반대입니다. 🎜🎜

위 내용은 정규식(정규)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!