day 17 markdown 총화

1. 정규 표현 식
from re import fullmatch, search, findall 정규 표현 식 은 문자열 이 특정한 규칙 에 만족 하 는 지 확인 하 는 도구 입 니 다.
1. 정규 문법 2. python 은 정규 표현 식 에 대한 지원 으로 내 장 된 모듈 을 제공 합 니 다. re 3. fullmatch (정규 표현 식, 문자열): 전체 문자열 이 정규 표현 규칙 에 부합 되 는 지 판단 합 니 다.
= = = = = = = = = = = = = = = = = 1. 단일 문자 = = = = = = = = = = = = = = = = = = = = = = = = =

re_str = r'.'
result = fullmatch(re_str, 'a')
print(sesult)

하나의 문자열 과 일치 합 니 다. 두 글자 만 있 고 이 모든 문 자 는 임 의 문자 입 니 다.

re_str = r'..'
result = fullmatch(re_str, 'an')
print(result)

문자열 에 일치 합 니 다. 앞의 세 자 리 는 abc 이 고 마지막 자 리 는 임의의 문자 입 니 다.

re_str = r'abc.'
result = fullmatch(re_str, 'abc%')
print(result)

2) \ w 는 알파벳 숫자 밑줄 과 일치 하 는 문자열 입 니 다. 앞의 세 자 리 는 abc 이 고 마지막 두 자 리 는 알파벳 숫자 나 밑줄 입 니 다.

re_str = r'abc\w\w'
result = fullmatch(re_str, 'abc2g')
print(result)

3) \ s 는 공백 문자 (공백 은 빈 칸, 탭 문자 (\ t) 와 리 턴 () 등 공백 이 생 길 수 있 는 모든 문자) 와 일치 합 니 다. 앞의 세 자 리 는 알파벳 숫자 밑줄 이 고 네 번 째 자 리 는 공백 문자 이 며 마지막 자 리 는 임 의 문자 입 니 다.

re_str = r'\w\w\w\s.'
result = fullmatch(re_str, 'hu2\t?')
print(result)

4) \ d 는 문자열 과 일치 하 는 숫자 문자 입 니 다. 앞의 세 자 리 는 숫자 문자 이 고 마지막 자 리 는 임 의 문자 입 니 다.

re_str = r'\d\d\d.'
result = fullmatch(re_str, '782l')
print(result)

5) \ \ b 단어 경계 여 부 를 검사 합 니 다.

re_str = r'when\b\swhere'
result = fullmatch(re_str, 'when where')
print(result)

6) ^ 문자열 이 주어진 정규 표현 식 으로 시작 하여 문자열 과 일치 하 는 지, 두 개의 숫자 문자 로 시작 하 는 지 확인 합 니 다.

re_str = r'\d\d'
result = fullmatch(re_str, '23')
print(result)

7) $문자 에서 주어진 정규 표현 식 으로 문자열 a 숫자 와 일치 하 는 지, 그리고 a 숫자 는 문자열 의 끝 입 니 다.

re_str = r'a\d$'
result = fulllmatch(re_str, 'a8')
print(result)

8) \ W 는 숫자, 알파벳, 밑줄 이 아 닌 문자 와 일치 합 니 다.

re_str = r'\W\w'
result = fullmatch(re_str, '!a')
print(result)

9) \ \ S 가 공백 문자 와 일치 하지 않 음

re_str = r'\S\w\w\w'
result = fullmatch(re_str, '@a3h')
print(result)

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

re_str = r'[abc+]\d\d'
result = fullmatch(re_str, '+67')
print(result)

주의:

-             ：                     。      '-'    ，         
[1-8]:        ：'1','2','3','4','5','6','7','8'
[-18]  [18-]:        '1','8','-'
             1-8    ，         
re_str = r'[1-8][a-z][a-z]'
result = fullmatch(re_str, '2hn')
print(result)

2. [^ 문자 집합] 일치 하지 않 는 문자 집합 에 있 는 임의의 문자 가 네 자리 문자열 과 일치 합 니 다. 첫 번 째 는 대문자 도 숫자 도 아니 고 세 번 째 는 abc 입 니 다.

re_str = r'[^A-Z\d]abc'
result = fullmatch(re_str, '#abc')
priint(result)

3) * 0 번 일치 하거나 여러 번 일치 하 는 문자열 입 니 다. 마지막 은 b 입 니 다. b 앞 에는 0 개 이상 의 a 가 있 습 니 다.

re_str = r'a*b'
print(fullmatch(re_str, 'aaab'))

한 번 또는 여러 번 (적어도 한 번) 일치 하 는 문자열 이 기호 가 없 는 정수 인지 판단 합 니 다

re_str = r'[1-9]+\d*'  # 10， 11， 100 ,1000
print(fullmatch(re_str, '1010'))

? 0 회 또는 1 회 일치

re_str = r'@?\d+'
print(fullmatch(re_str, '@16723'))
            (         )
+200, -120, 99, -1, 3, +4
re_str = r'[+-]?[1-9]+\d*'
print(fullmatch(re_str, '200'))

{N} N 회 일치

re_str = r'\d{3}'      #   3      
re_str = r'[a-zA-Z]{3}'   #   3      
print(fullmatch(re_str, 'aHh'))

{N,} 최소 N 회 일치

re_str = r'\w{4,}'
print(fullmatch(re_str, 'hanc_123'))

{, N} 최대 N 회 일치

re_str = r'a{,4}b'  # 'b', 'ab', 'aab', 'aaab','aaaab'
print(fullmatch(re_str, 'aaaab'))

{M, N} 매 칭 최소 M 회, 최대 N 회 (N > M)

re_str = r'a{2,4}b'  # 'aab', 'aaab', 'aaaab'
print(fullmatch(re_str, 'aaab'))

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

| 분 의 (논리 연산 에 해당 하 는 or) 일치 하 는 문자열 은 세 글자 또는 세 숫자

입 니 다.

re_str = r'[a-zA-Z]{3}|\d{3}'
print(fullmatch(re_str, 'abc'))
'\d{3}[a-z]{2}'          ， '[A-F]{3}'         
re_str = r'\d{3}[a-z]{2}|[A-F]{3}'
print(fullmatch(re_str, 'ABC'))

메모: 정규 에서 단락 작업 이 있 습 니 다. | 를 사용 하여 여러 조건 을 연결 하면 앞의 조건 이 결과 와 일치 합 니 다. 그러면 뒤의 조건 을 사용 하지 않 고 연습 과 일치 합 니 다. 정규 표현 식 을 쓰 면 문자열 의 모든 숫자 (정수 와 소수 포함) 와 일치 할 수 있 습 니 다.

'abc12.5hhh60,30.2kkk9nn0.12'
100, 89.89, 20.12, 0.23
re_str = r'[1-9]\d*[.]?\d*|0[.]\d+'
print()
re_str = r'[1-9]\d*|\d+[.]\d+'
re_str = r'\d+[.]\d+|[1-9]\d*'
print(findall(re_str, 'abc12.5hhh60,30.2kkk9nn0.12'))

그룹 a. 그룹 을 나 누 면 플러스 () 를 통 해 정규 조건 을 나 누 어 두 개의 숫자 두 자 모 를 3 번 ac23bn45hj 34

로 나눈다.

re_str = r'([a-z]{2}\d{2}){3}'
print(fullmatch(re_str, 'ac23bn45hj34'))

하나의 문자열 과 일치 하 며, 하나의 숫자 에 따라 한 자모의 규칙 에 따라 한 번 또는 여러 번 나타 납 니 다.

re_str = r'(\d[a-z])+'
print(fullmatch(re_str, '9a2s3k4k9o'))

b. 앞의 그룹 에 일치 하 는 결 과 를 \ 숫자 로 반복 할 수 있 습 니 다.숫자의 값 은 앞의 몇 번 째 그룹 을 대표 합 니 다.

re_str = r'(\d{2}[A-Z])=%\1\1'
print(fullmatch(re_str,'23B=%23B23B'))

re_str = r'(\d{3})-(\w{2})\1{2}\2'
print(fullmatch(re_str,'123-aa123123aa'))

c. 캡 처 는 전체 정규 표현 식 에 따라 일치 하고 () 의 내용 만 캡 처 합 니 다.findall 에서 만 유효 합 니 다.

re_str = r'a(\d{3})b'
print(fullmatch(re_str, 'a786b'))
print(findall(re_str, 'a786b'))

정규 중의 전의
1. 정규 표현 식 의 전의 와 문자열 의 전의 문 자 는 아무런 관계 가 없습니다.python 의 문자열 앞 에 r 를 붙 여 문자열 의 전 의 를 막 습 니 다. 정규 표현 식 의 전 의 를 막 을 수 없습니다. 2. 정규 표현 식 에 서 는 특별한 의미 가 있 는 기호 앞 에 \ 를 붙 여 기호 자 체 를 표시 할 수 있 습 니 다 +. *? \() ^ $| 주의:

a.-                      
b.        []         ，    -                  
c.\           ， ^             

예 를 들 면:

re_str = r'a\+'
print(re.fullmatch(re_str, 'a+'))

re_str = r'\+a'
print(re.fullmatch(re_str, '+a'))

re_str = r'\\w-a'
print(re.fullmatch(re_str, '\w-a'))

re_str = r'\(\d{3}'
print(re.fullmatch(re_str,'(234'))

re_str = r'\[abc\]'

re_str = r'[\^.?*]mbc\\'
print(re.fullmatch(re_str, '?mbc\\'))

re 모듈
1. copile (정규 표현 식): 정규 표현 식 을 정규 표현 식 대상 으로 변환 합 니 다.

re_str = r'\d+'
re_object = re.compile(re_str)
print(re_object)
     ，       
re.fullmatch(re_str, '78hj')
     ，       
re_object.fullmatch('78hj')

2. match (정규 표현 식, 문자열) 와 fullmatch (정규 표현 식, 문자열) match: 문자열 의 시작 이 정규 표현 식 과 일치 할 수 있 는 지 여 부 를 판단 합 니 다. 전체 문자열 이 정규 표현 식 과 일치 할 수 있 는 지 여 부 를 판단 합 니 다. 일치 할 경우 일치 하 는 대상 을 되 돌려 줍 니 다. 그렇지 않 으 면 None 로 돌아 갑 니 다.

re_str = r'abc\d{3}'
match1 = re.match(re_str, 'abc234abcdef')
match2 = re.fullmatch(re_str, 'abc234')
print(match1)
print(match2)

a. 일치 하 는 범위.결과 문자 와 일치 하 는 아래 표지 범위: (시작 표시, 끝 표시) - 끝 표시 에서 print (match1. span () 를 가 져 올 수 없습니다. 출발점 print (match1. start () 를 가 져 옵 니 다. 종점 print (match1. end () 를 가 져 옵 니 다. 주의: group 매개 변 수 는 그룹 에 대응 하 는 결 과 를 지정 합 니 다.

re_str = r'(\d{3})\+([a-z]{2})'
match1 = re.match(re_str, '234+hjaaaaaa')
print(match1)
print(match1.span())
      ，   1      
print(match1.span(1))
      ，   2      
print(match1.span(2))
      ，   2        
print(match1.start(2))

b. 일치 하 는 결과 에 대응 하 는 문자열 print (match1. group () print (match1. group (1) print (match1. group (2) 가 져 오기
c. 일치 하 는 원래 문자열 print (match 1. string) 3. search (정규 표현 식, 문자열) 를 가 져 옵 니 다. 문자열 에서 정규 표현 식 의 요 구 를 만족 시 키 는 첫 번 째 하위 문자열 을 찾 습 니 다. 찾 으 면 일치 하 는 대상 으로 돌아 갑 니 다. None 로 돌아 갈 수 없습니다.

search1 = re.search(r'\d+aa', 'he9aallo 78aabc wolrd')
print(search1)
if search1:
    print(search1.span())

연습: search 를 사용 하여 한 문자열 의 모든 숫자 문자열 을 찾 습 니 다.

str1 = '   10000 ，   18 ，   ：180，  100 '
re_str = r'[1-9]\d*'
search1 = re.search(re_str, str1)
while search1:
    print(search1.group())
    end = search1.end()
    str1 = str1[end:]
    search1 = re.search(re_str, str1)

4. split (정규 표현 식, 문자열) 정규 표현 식 을 만족 시 키 는 하위 문자열 에 따라 문자열 의 반환 값 을 자 르 는 것 이 목록 입 니 다.

str1 = '     ,     。     ，     !'
result = re.split(r'\W+', str1)
print(result)

5. sub (정규 표현 식, 문자열 교체, 교 체 된 문자열) 반환 값 은 새 문자열 입 니 다.

word = '      ?       . Fuck you'
result = re.sub(r'  | |Fuck|  ', '*', word)
print(result)

6. findall (정규 표현 식, 문자열) 에서 정규 표현 식 을 만족 시 키 는 모든 하위 문자열 반환 값 을 가 져 옵 니 다. 목록 주의: 그룹 에서 의 캡 처 효 과 는 여기 서 유효 합 니 다.

result = re.findall(r'\d([a-z]+)', '   1boy,and    0action')
print(result)