파이썬 - 정규식(RE) 모듈

정규식

정규식은 문자열 내의 문자 조합을 일치시키고, 검색하며, 교체하는 데 사용되는 강력한 텍스트 처리 도구입니다. 특별한 문법을 사용하여 복잡한 패턴을 정의할 수 있습니다.

일, re 모듈: 파이썬 언어에 정규식의 모든 기능을 제공합니다

"re 모듈"은 파이썬에서 정규식을 처리하기 위한 표준 라이브러리로, "Regular Expression"의 약자입니다. 정규식의 일치, 검색, 교체 및 분할 작업을 수행하기 위한 여러 함수를 제공합니다.

간단한 예시: 이메일 주소 정규식

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

이 정규식의 의미는 다음과 같습니다:

  • ^는 문자열의 시작을 나타냅니다.
  • [a-zA-Z0-9._%+-]+는 @ 기호 앞의 로컬 부분을 일치시키며, 하나 이상의 알파벳, 숫자 또는 특정 특수 문자를 허용합니다.
  • @는 리터럴 @ 문자를 일치시킵니다.
  • [a-zA-Z0-9.-]+는 도메인 이름을 일치시키며, 하나 이상의 알파벳, 숫자, 점 또는 하이픈을 허용합니다.
  • \.는 리터럴 점 문자를 일치시킵니다 (정규식에서 .는 모든 문자를 의미하므로 \로 이스케이프 처리).
  • [a-zA-Z]{2,}는 최소 2자 이상의 최상위 도메인을 일치시킵니다.
  • $는 문자열의 끝을 나타냅니다.

re.match() 함수를 사용한 일치 확인:

리스트에서 모든 이메일 주소를 확인하고, 각 주소가 유효한지 검사하여 유효한 경우 "올바른 형식"을, 그렇지 않은 경우 "잘못된 형식"을 출력합니다.

import re

# 이메일 주소 목록
emails = ["user@example.com", "invalid-email", "test@test.org", "another@domain.net"]

# 이메일 주소 형식을 검사하는 정규식 패턴
email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

# 목록의 각 요소를 순회하며 검사
for email in emails:
    # re.match() 함수를 사용하여 일치 확인
    if re.match(email_pattern, email):
        print(f"{email}: 이메일 형식이 올바릅니다")
    else:
        print(f"{email}: 이메일 형식이 잘못되었습니다")

함수 호출 방식으로 변경:

import re

def validate_email(email):
    # 이메일 주소 형식을 검사하는 정규식 패턴
    email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    # re.match() 함수를 사용하여 일치 확인
    if re.match(email_pattern, email):
        return "이메일 형식이 올바릅니다"
    else:
        return "이메일 형식이 잘못되었습니다"

# 이메일 주소 목록
email_list = ["user@example.com", "invalid-email", "test@test.org", "another@domain.net"]

# 목록의 각 요소를 순회하며 함수를 호출하여 검사
for email in email_list:
    print(f"{email}: {validate_email(email)}")

2, 정규식 기본 문법:

1, 단일 문자 및 숫자 일치

일치 설명
. 줄바꿈 문자를 제외한 모든 문자와 일치. flags가 re.S로 설정되면 줄바꿈 문자를 포함한 모든 문자와 일치
[] 문자 집합 내의 임의의 한 문자와 일치
[0123456789] 임의의 한 숫자 문자와 일치
[0-9] 임의의 한 숫자 문자와 일치
[a-z] 임의의 한 소문자 영문 알파벳 문자와 일치
[A-Z] 임의의 한 대문자 영문 알파벳 문자와 일치
[A-Za-z] 임의의 한 영문 알파벳 문자와 일치
[A-Za-z0-9] 임의의 한 숫자 또는 영문 알파벳 문자와 일치
^[abcde] "a", "b", "c", "d" 또는 "e"로 시작하는 단일 문자의 문자열과 일치. ^는 일반적으로 "앵커" 또는 "시작 앵커"라고 함
[^a-e] [] 안의 ^는 부정 문자(deletion character)라고 하며, [] 안에 없는(a-e) 임의의 한 문자와 일치
\d 임의의 한 숫자 문자와 일치, [0-9]와 동일
\D 임의의 한 숫자가 아닌 문자와 일치, [^0-9]와 동일
\w 알파벳, 밑줄, 숫자 중 임의의 한 문자와 일치, [0-9A-Za-z_]와 동일
\W 알파벳, 밑줄, 숫자가 아닌 임의의 한 문자와 일치, [^0-9A-Za-z_]와 동일
\s 공백, 페이지 넘김, 줄바꿈, 캐리지 리턴, 탭과 같은 공백 문자와 일치, [ \f\n\r\t]와 동일
\S 공백 문자가 아닌 문자와 일치, [^ \f\n\r\t]와 동일

예제 1: "hello" 문자열에서 정규식 [^helo]를 사용하여 일치시킬 때, [^helo]는 [^helo]와 동일하게 동작하며, 문자열의 각 문자를 순서대로 검사하여 helo 집합에 없는지 확인합니다.

여기서 l이 두 번 나타나지만, 문자 집합에서 중복 문자는 특별한 의미를 갖지 않으며, 단일 문자로만 일치시킵니다. 따라서 [^hello]와 [^helo]는 기능적으로 동일합니다.

  • 'w' 문자는 helo에 없으므로 일치합니다.
  • 다음으로 'o' 문자를 확인하지만, 'o'는 helo에 있으므로 일치하지 않습니다.
  • 그 다음 'r' 문자는 helo에 없으므로 일치합니다.
  • 그 다음 'l' 문자는 helo에 있으므로 일치하지 않습니다.
  • 마지막으로 'd' 문자는 helo에 없으므로 일치합니다.

따라서 "hello" 문자열에서 [^helo]를 사용하여 일치시키면, 'h', 'e', 'o' 문자가 일치합니다. 이 세 문자는 문자열에서 helo 집합에 없는 문자입니다. [^helo]는 단일 문자만 일치시키므로, 각 조건에 맞는 문자를 개별적으로 일치시키며 전체 하위 문자열이나 단어와 일치시키지는 않습니다.

hello: 첫 번째 문자 일치, h
apple8901: 첫 번째 문자 불일치, [^a-e]
camp123: 첫 번째 문자 불일치, [^a-e]
word5678: 첫 번째 문자 일치, w
'hello': 일치됨, [^a-e]: ['h', 'l', 'o']
'apple8901': 일치됨, [^a-e]: ['p', 'p', 'l', '8', '9', '0', '1']
'camp123': 일치됨, [^a-e]: ['m', 'p', '1', '2', '3']
'word5678': 일치됨, [^a-e]: ['w', 'o', 'r', '5', '6', '7', '8']

2, 앵커 문자 일치

앵커 문자: 특정 규칙에 따라 시작 또는 끝인지 판별하는 데 사용됩니다

일치 설명
^ 행 시작 일치, [] 안의 ^와는 다른 의미
$ 행 끝 일치

3, 한정자

한정자는 정규식의 특정 구성 요소가 일치하기 위해 몇 번 나타나야 하는지 지정합니다. * 또는 + 또는 ? 또는 {n} 또는 {n,} 또는 {n,m} 총 6가지가 있습니다.

일치 설명
(xyz) 괄호 안의 xyz를 하나의 단위로 일치시킵니다. 하나의 단위로 저장됩니다.
x? 0개 또는 1개의 x와 일치합니다. 비 탐욕적 일치
x* 0개 또는 여러 개의 x와 일치합니다.
x+ 최소 1개의 x와 일치합니다.
x{n} 정확히 n개의 x와 일치합니다. n은 음이 아닌 정수입니다.
x{n,} 최소 n개의 x와 일치합니다.
x{n,m} 최소 n개, 최대 m개의 x와 일치합니다.
x|y |는 또는의 의미로, x 또는 y와 일치합니다.

4, 일반 flags(수정자)

flags 매개변수는 정규식의 일치 방식을 제어하는 데 사용됩니다. 선택적 매개변수로서, 다양한 일치 플래그를 지정할 수 있으며, 여러 플래그를 조합(비트 OR | 연산자 사용)할 수 있습니다.

일반적으로 사용되는 flags에는 다음과 같은 것들이 있습니다:

  • re.IGNORECASE 또는 re.I: 일치가 대소문자를 구분하지 않도록 합니다.
  • re.MULTILINE 또는 re.M: 시작 및 종료 문자 ^와 $가 각각 각 줄의 시작과 끝과 일치하도록 하며, 전체 문자열의 시작과 끝과는 일치하지 않습니다.
  • re.DOTALL 또는 re.S: . 특수 문자가 줄바꿈을 포함한 모든 문자와 일치하도록 합니다.
  • re.VERBOSE 또는 re.X: 이 플래그는 정규식에 주석을 작성할 수 있게 하여 정규식을 더 읽기 쉽게 만듭니다.
값 설명
re.I 대소문자를 구분하지 않고 일치
re.S .가 줄바꿈을 포함한 모든 문자와 일치하도록 함
re.M 시작과 종료 문자 ^와 $가 각각 각 줄의 시작과 끝과 일치하도록 함. 전체 문자열의 시작과 끝과는 일치하지 않음.
re.X 이 플래그는 정규식에 주석을 작성할 수 있게 하여 정규식을 더 읽기 쉽게 만듦

예를 들어, re.IGNORECASE를 사용하면 대소문자를 구분하지 않고 일치시킬 수 있습니다:

import re

pattern = re.compile(r'apple', flags=re.IGNORECASE)
string = 'This is an Apple, and that is an apple.'

matches = pattern.findall(string)
print(matches)  # 출력: ['Apple', 'apple']

이 예제에서는 "Apple"과 "apple"의 대소문자가 다르지만, re.IGNORECASE 플래그를 사용했기 때문에 두 문자열 모두 일치됩니다.

필요에 따라 이 플래그들을 조합할 수 있습니다. 예를 들어, 대소문자를 무시하고 .가 줄바꿈을 포함한 모든 문자와 일치하도록 하려면 다음과 같이 할 수 있습니다:

pattern = re.compile(r'.*', flags=re.IGNORECASE | re.DOTALL)

예제 2, re.MULTILINE을 사용한 다중 줄 일치:

re.MULTILINE 플래그가 설정되면(re.M로 약칭), 정규식의 시작 및 종료 문자 ^와 $가 각각 각 줄의 시작과 끝과 일치하며, 전체 문자열의 시작과 끝과는 일치하지 않습니다.

이것은 다중 줄 텍스트를 처리할 때 특히 유용하며, 각 줄의 시작이나 끝에서 일치시켜야 할 때 사용됩니다. re.MULTILINE 플래그를 설정하지 않으면, ^와 $는 기본적으로 전체 문자열의 시작과 끝과 일치합니다.

import re

# 다중 줄 문자열 정의
text = """
이것은 첫 번째 줄입니다
이것은 두 번째 줄입니다
이것은 세 번째 줄입니다
"""

# re.MULTILINE 플래그를 사용하여 각 줄 시작의 "이것"을 찾기
pattern = re.compile(r'^이것', flags=re.MULTILINE)
matches = pattern.findall(text)
print(matches)  # 출력: ['이것', '이것', '이것']

5, pattern 문법

문자열 '정규식' 앞의 접두사 r 또는 R은 이 문자열이 원시 문자열(raw string)임을 나타냅니다.

pattern = r'정규식'

원시 문자열 사용:

pattern = r'^1[34578]\d{9}$'

만약 문자열 '^1[34578]\d{9}$'이 r로 표시되지 않으면, 문자열의 백슬래시 \는 일반 문자로 처리되며, 이스케이프 문자로 처리되지 않습니다. 정규식에서 백슬래시는 특수 문자를 도입하거나 일반 문자를 이스케이프하는 데 사용됩니다. 따라서 원시 문자열을 사용하지 않고 정규식의 특수 문자를 나타내려면, 단일 백슬래시 \ 대신 이중 백슬래시 \\를 사용해야 합니다. 예를 들어:

원시 문자열 사용 안 함:

pattern = '^1[34578]\\d{9}$'

정규식에서 ^와 $는 특수 문자이지만, 이들은 이스케이프 문자로 처리될 필요가 없습니다. 이들은 원시 문자열을 사용하지 않는 경우에도(r 접두사 사용하지 않음) 동일한 방식으로 작성됩니다. 왜냐하면 ^와 $는 문자열 내에서 특별한 이스케이프 의미를 갖지 않으며, 정규식의 맥락에서만 특수 문자로 해석되기 때문입니다.

원시 문자열을 사용하는지 여부와 관계없이 ^와 $의 작성 방식은 동일합니다:

요약: 정규식의 경우, 원시 문자열을 사용하면 문자 작성이 간소화되며, 백슬래시(\d, \w, \s 등)를 잊어서 발생하는 오류를 방지할 수 있습니다. 따라서 정규식을 정의할 때 일반적으로 원시 문자열 사용을 권장합니다. pattern = r'정규식'

3, re 모듈의 일반 함수 사용법

1, re 모듈의 일반적인 함수 및 주요 기능:

  1. re.match(pattern, string, flags=0)
  • 기능: 문자열의 시작 위치에서 패턴을 일치시키고, 일치에 성공하면 Match 객체를 반환하며, 그렇지 않으면 None을 반환합니다. ``` import re

목록

items = ["hello", "apple8901", "camp123", "word5678"]

규칙을 일치시키는 정규식 패턴 정의

pattern = r'[^a-e] # a-e가 아닌 문자

목록의 각 요소를 순회하며 일치 확인

for item in items: # re.match(첫 번째 문자 일치) 구문 result = re.match(pattern, item) if result: print(f"{item}: 첫 번째 문자 일치: {result.group()}") else: print(f"{item}: 첫 번째 문자 불일치!")

실행 결과

hello: 첫 번째 문자 일치: h apple8901: 첫 번째 문자 불일치! camp123: 첫 번째 문자 불일치! word5678: 첫 번째 문자 일치: w

2. **re.search(pattern, string, flags=0)**
- 기능: 전체 문자열을 스캔하여 첫 번째 일치 결과를 반환하고, 일치에 성공하면 Match 객체를 반환하며, 그렇지 않으면 None을 반환합니다. ```
import re

# 여러 문자열을 포함한 목록, 중국어 문자가 포함될 수 있음
texts = ["저는 파이썬을 배우는 것을 좋아합니다", "파이썬은 재미있어요", "중국어 배우는 것도 중요해요"]

# "배우는"이라는 단어를 포함하는 항목을 검색하기 위한 정규식 패턴 정의
pattern = r'배우는'

# 목록의 각 문자열을 순회하며 일치 항목 검색
for text in texts:
    match = re.search(pattern, text)
    if match:
        # 일치 항목을 찾은 경우, 원래 문자열과 위치를 출력
        print(f"'{text}'에서 일치: {match.group()} (위치: {match.start()})")
    else:
        print(f"'{text}'에서 일치 항목 없음")
        
# 결과
'저는 파이썬을 배우는 것을 좋아합니다'에서 일치: 배우는 (위치: 5)
'파이썬은 재미있어요'에서 일치 항목 없음
'중국어 배우는 것도 중요해요'에서 일치: 배우는 (위치: 3)
  1. re.findall(pattern, string, flags=0)
  • 기능: 텍스트에서 정규식과 일치하는 모든 문자열을 검색하고 문자열 목록을 반환합니다. ``` import re

목록

items = ["hello", "apple8901", "camp123", "word5678"]

규칙을 일치시키는 정규식 패턴 정의

pattern = r'[^a-e] # a-e가 아닌 문자

테스트 문자열을 순회하며 일치 결과 출력

for s in items: # re.findall 모든 문자 분리 일치 matches = re.findall(pattern, s) print(f"'{s}': 일치, {pattern}: {matches}")

결과

'hello': 일치, [^a-e]: ['h', 'l', 'o'] 'apple8901': 일치, [^a-e]: ['p', 'p', 'l', '8', '9', '0', '1'] 'camp123': 일치, [^a-e]: ['m', 'p', '1', '2', '3'] 'word5678': 일치, [^a-e]: ['w', 'o', 'r', '5', '6', '7', '8']

4. **re.finditer(pattern, string, flags=0)**
- 기능: `findall`과 유사하지만, 반복자를 반환하며 각 반복 요소는 Match 객체입니다. ```
import re

# 날짜가 포함된 문자열 정의
text = "제 생일은 2023-03-15이고, 친구의 생일은 2022-09-20과 2021-01-01입니다."

# 날짜(YYYY-MM-DD)를 일치시키기 위한 정규식 패턴 정의
pattern = r'\b\d{4}-\d{2}-\d{2}\b'  # \b는 단어 경계를 의미, \d는 숫자를 의미

# re.finditer()를 사용하여 모든 일치 항목 찾기
matches = re.finditer(pattern, text)

# 일치 항목을 순회하며 결과 출력
for match in matches:
    print(f"일치 항목 발견: {match.group()} (위치: {match.start()})")
    
# 결과
일치 항목 발견: 2023-03-15 (위치: 6)
일치 항목 발견: 2022-09-20 (위치: 21)
일치 항목 발견: 2021-01-01 (위치: 34)
  1. re.split(pattern, string, maxsplit=0, flags=0)
  • 기능: 텍스트에서 정규식과 일치하는 문자열을 구분자로 사용하여 텍스트를 목록으로 분할합니다. ``` import re

쉼표로 구분된 문자열 목록, 추가 공백이 포함될 수 있음

text = "사과, 바나나 , 체리, 날짜"

쉼표 및 앞뒤 공백을 일치시키는 정규식 패턴 정의

pattern = r'\s*,\s*' # \s는 공백, 탭, 줄바꿈 등 공백 문자를 의미

re.split()을 사용하여 패턴에 따라 문자열 분할, 최대 분할 횟수를 2로 설정

split_list = re.split(pattern, text, maxsplit=2)

분할된 목록 출력

print(split_list)

maxsplit이 2로 설정되었으므로, 두 번만 분할되고 나머지 문자열'체리, 날짜'는 원래 상태로 유지됩니다.

['사과', '바나나', '체리, 날짜']

6. **re.sub(pattern, repl, string, count=0, flags=0)**
- 기능: 텍스트에서 정규식과 일치하는 문자열을 지정된 문자열로 검색하고 교체한 후, 교체된 텍스트를 반환합니다. ```
import re  
  
# 여러 문자열을 포함하는 목록  
sentences = ["저는 1개의 사과가 있습니다", "그는 2권의 책이 있습니다", "그녀는 30원을 썼습니다"]  
  
# 숫자를 일치시키기 위한 정규식 패턴 정의  
number_pattern = r'\d+'  
  
# 교체 문자열 정의  
replacement = 'N'  
  
# 목록 내 각 문자열의 숫자를 교체하기 위해 목록 내포 사용  
new_sentences = [re.sub(number_pattern, replacement, s) for s in sentences]  
  
# 교체된 문자열 목록 출력  
print(new_sentences)

# 결과
['저는 N개의 사과가 있습니다', '그는 N권의 책이 있습니다', '그녀는 N원을 썼습니다']
  1. re.subn(pattern, repl, string, count=0, flags=0)
  • 기능: sub와 유사하지만, 교체된 텍스트와 교체 횟수를 포함하는 튜플을 반환합니다. ``` import re

여러 문자열을 포함하는 목록

phrases = ["저는 1개의 사과가 있습니다", "그는 2권의 책이 있습니다", "그녀는 3개의 펜과 1개의 가방을 샀습니다", "총 가격은 45원입니다"]

숫자를 일치시키기 위한 정규식 패턴 정의

number_pattern = r'\d+'

교체 문자열 정의

replacement = 'N'

교체된 문자열과 교체 횟수를 저장할 빈 목록 초기화

replaced_phrases = []
replacement_counts = []

목록의 각 문자열을 순회하며 re.subn()을 사용하여 교체하고 교체 횟수 가져오기

for phrase in phrases:
replaced_phrase, count = re.subn(number_pattern, replacement, phrase)
replaced_phrases.append(replaced_phrase)
replacement_counts.append(count)

교체된 문자열 목록 출력

print("교체된 문자열 목록:")
print(replaced_phrases)

각 문자열의 교체 횟수 목록 출력

print("각 문자열의 교체 횟수:")
print(replacement_counts)

교체된 문자열 목록:

['저는 N개의 사과가 있습니다', '그는 N권의 책이 있습니다', '그녀는 N개의 펜과 N개의 가방을 샀습니다', '총 가격은 N원입니다']
각 문자열의 교체 횟수:
[1, 1, 2, 1]

- `phrases` 목록의 각 문자열을 순회하며 `re.subn()` 함수를 사용하여 숫자를 교체합니다. 각 문자열에 대해 `re.subn()`은 교체된 문자열과 교체 횟수를 포함하는 튜플을 반환합니다. 이 두 값은 각각 `replaced_phrases`와 `replacement_counts` 목록에 추가됩니다. 마지막으로 교체된 문자열 목록과 각 문자열의 교체 횟수 목록을 출력합니다.

이 방법을 통해 교체된 문자열뿐만 아니라 각 문자열에서 몇 번의 교체 작업이 수행되었는지도 알 수 있습니다. 이는 특정 패턴의 출현 빈도를 분석하는 데 매우 유용합니다.
8. **re.escape(pattern)**
- 기능: 문자열의 정규식 특수 문자를 이스케이프합니다. ```
import re  
  
# 사용자 입력 문자열이 있다고 가정하며, 이를 정규식의 일부로 사용하고자 함  
user_input = "example.com"  
  
# 정규식을 빌드할 때 user_input의 점(.)이 정규식에서 특수 문자(점은 정규식에서 임의의 문자를 의미)로 처리되지 않도록 해야 함  
escaped_input = re.escape(user_input)  
  
# 이제 안전하게 정규식에서 escaped_input을 사용할 수 있음  
pattern = r"http://{}".format(escaped_input)  
  
# 대상 문자열을 포함하는 텍스트 생성  
content = "http://example.com에 방문하여 더 많은 정보를 얻으세요."  
  
# re.search()를 사용하여 일치 항목 찾기  
match = re.search(pattern, content)  
  
# 일치 항목을 찾은 경우 출력  
if match:  
    print("일치 항목 발견:", match.group())  
else:  
    print("일치 항목을 찾을 수 없습니다.")
  • 이 예제에서 사용자가 example.com 문자열을 입력했고, 이를 URL의 일부로 일치시키기 위한 정규식을 빌드하고자 합니다. 점(.)은 정규식에서 특수 의미를 갖기 때문에(임의의 문자를 의미), re.escape()를 사용하여 이스케이프 처리해야 합니다. 이렇게 하면 점이 일반 문자로 처리됩니다.

re.escape(user_input)는 example\.com을 반환하므로, 정규식에 안전하게 포함할 수 있으며 정규식의 일치 동작을 방해하지 않습니다. 그런 다음 정규식 pattern을 빌드하고 content 문자열에서 일치 항목을 검색하는 데 사용합니다.

content에 http://example.com이 포함된 경우, re.search()는 일치 항목을 찾아 출력합니다. content에 해당 문자열이 포함되지 않거나 형식이 올바르지 않으면 일치 항목을 찾을 수 없습니다. 9. re.compile(pattern, flags=0)

  • 기능: 정규식을 Pattern 객체로 컴파일하여, 해당 객체를 여러 번 사용하여 일치시킬 수 있습니다. ``` import re

phrases = ["저는 1개의 사과가 있습니다", "그는 2권의 책이 있습니다", "그녀는 3개의 펜을 샀습니다", "테이블 위에는 4개의 컵이 있습니다"]

pattern_str = r'\d+' # 하나 이상의 숫자와 일치

pattern = re.compile(pattern_str)

for phrase in phrases: match = pattern.search(phrase) if match: print(f"'{phrase}'에서 숫자를 찾았습니다: {match.group()}") else: print(f"'{phrase}'에서 숫자를 찾을 수 없습니다")

결과

'저는 1개의 사과가 있습니다'에서 숫자를 찾았습니다: 1 '그는 2권의 책이 있습니다'에서 숫자를 찾았습니다: 2 '그녀는 3개의 펜을 샀습니다'에서 숫자를 찾았습니다: 3 '테이블 위에는 4개의 컵이 있습니다'에서 숫자를 찾았습니다: 4

- `pattern = re.compile(pattern_str)`를 사용하여 정규식을 컴파일함으로써, 동일한 정규식을 여러 번 사용할 때 효율성을 높일 수 있습니다. 컴파일 과정은 단 한 번만 수행되기 때문입니다. 이는 대량의 텍스트를 처리하거나 동일한 정규식을 자주 사용해야 할 때 매우 유용합니다.
- 단일 호출과의 비교 ```
import re

phrases = ["저는 1개의 사과가 있습니다", "그는 2권의 책이 있습니다", "그녀는 3개의 펜을 샀습니다", "테이블 위에는 4개의 컵이 있습니다"]

pattern = r'\d+'  # 하나 이상의 숫자와 일치

for phrase in phrases:
    match = re.search(pattern, phrase)
    if match:
        print(f"'{phrase}'에서 숫자를 찾았습니다: {match.group()}")
    else:
        print(f"'{phrase}'에서 숫자를 찾을 수 없습니다")
  1. re.purge()
  • 기능: 정규식 캐시를 지웁니다.
  1. re.escape(string)
  • 기능: 문자열의 특수 문자를 이스케이프하여 일반 문자로 처리될 수 있도록 합니다.
  1. re.fullmatch(pattern, string, flags=0)
  • 기능: 전체 문자열이 패턴과 완전히 일치해야 하며, 성공하면 Match 객체를 반환하고 그렇지 않으면 None을 반환합니다.
  1. re.search(pattern, string, pos, endpos)
  • 기능: re.search()와 유사하지만, 검색의 시작 및 끝 위치를 지정할 수 있습니다.
  1. re.match(pattern, string, pos, endpos)
  • 기능: re.match()와 유사하지만, 일치의 시작 및 끝 위치를 지정할 수 있습니다.
  1. re.ASCII, re.IGNORECASE, re.MULTILINE, re.DOTALL, re.UNICODE, re.VERBOSE 등
  • 기능: 이러한 정규식 플래그는 정규식의 일치 동작을 수정하는 데 사용됩니다.

이러한 함수와 플래그는 강력한 정규식 처리 기능을 제공하여 파이썬이 복잡한 텍스트 일치 및 교체 작업을 쉽게 수행할 수 있도록 합니다. 이러한 함수를 사용할 때는 일반적으로 정규식 문법과 결합하여 일치 패턴을 작성해야 합니다.

2, 주요 매개변수 및 사용법 상세 설명.

1. re.sub(pattern, repl, string, count=0, flags=0)

re.sub() 함수는 문자열에서 정규식의 모든 중복되지 않는 일치 항목을 찾아 다른 문자열로 교체하는 데 사용됩니다.

  • pattern: 찾을 정규식 패턴입니다.
  • repl: 일치 항목을 교체할 문자열 또는 함수입니다.
  • string: 검색 및 교체 작업을 수행할 원본 문자열입니다.
  • count: 선택적 매개변수로, 교체할 최대 일치 횟수를 나타냅니다. 기본값은 0으로, 모든 일치 항목을 교체함을 의미합니다.
  • flags: 선택적 매개변수로, 정규식의 일치 방식을 수정하는 데 사용됩니다.

예제 1:

import re  

target = "world"  
replacement = "Python"  
text = "Hello, world! This is the world we live in."  
result = re.sub(target, replacement, text, count=1)  
print(result)  # 출력: Hello, Python! This is the world we live in.

이 예제에서는 "world"의 첫 번째 일치 항목이 "Python"으로 교체됩니다. count=1이 설정되었으므로 첫 번째 일치 항목만 교체됩니다.

2. re.split(pattern, string, maxsplit=0, flags=0)

re.split() 함수는 정규식의 일치 항목을 기준으로 문자열을 분할합니다.

  • pattern: 문자열을 분할할 기준이 되는 정규식 패턴입니다.
  • string: 분할할 문자열입니다.
  • maxsplit: 선택적 매개변수로, 최대 분할 횟수를 나타냅니다. 기본값은 0으로, 분할 횟수에 제한이 없음을 의미합니다.
  • flags: 선택적 매개변수로, 정규식의 일치 방식을 수정하는 데 사용됩니다.

예제 2:

import re

pattern = r'\d+'  # 하나 이상의 숫자와 일치
text = 'one1two2three3four'

# maxsplit 설정 안 함
split_result_no_limit = re.split(pattern, text)
print(split_result_no_limit)  # 출력: ['one', 'two', 'three', 'four']

# maxsplit을 1로 설정  
split_result_limited = re.split(pattern, text, maxsplit=1)
print(split_result_limited)  # 출력: ['one', 'two2three3four']

# maxsplit을 2로 설정
split_result_limited_more = re.split(pattern, text, maxsplit=2)
print(split_result_limited_more)  # 출력: ['one', 'two', 'three3four']

이 예제에서는 숫자(\d+)를 기준으로 문자열을 여러 부분으로 분할합니다.

3. re.findall(pattern, string, flags=0)

re.findall() 함수는 문자열에서 정규식의 모든 중복되지 않는 일치 항목을 찾아 목록으로 반환합니다.

  • pattern: 찾을 정규식 패턴입니다.
  • string: 검색 작업을 수행할 문자열입니다.
  • flags: 선택적 매개변수로, 정규식의 일치 방식을 수정하는 데 사용됩니다.

예제 3:

import re  
  
pattern = r'\d+'  
text = "one1two2three3four"  
result = re.findall(pattern, text)  
print(result)  # 출력: ['1', '2', '3']

이 예제에서는 문자열의 모든 숫자를 찾아 목록으로 반환합니다.

위 함수들에서 flags 매개변수는 일반적으로 정규식의 일치 동작을 수정하는 데 사용되며, 예를 들어 re.IGNORECASE(대소문자 무시) 또는 re.MULTILINE(다중 줄 모드) 등이 있습니다. maxsplit 매개변수는 re.split()과 관련이 있으며, 분할의 최대 횟수를 제한하는 데 사용됩니다.

태그: 정규식 파이썬 re 모듈 문자열 처리

7월 7일 00:57에 게시됨

인기 태그

©2026 괴물 클럽