야, 솔직히 말해봐. 😅 코딩하다가 텍스트 처리할 때 "이거 어떻게 뽑아내지?" 하면서 멍 때린 적 있지 않아?
로그 파일에서 특정 패턴 찾기, 이메일 주소 유효성 검사, HTML 태그 제거, 전화번호 형식 통일…
이런 작업들을 일일이 반복문으로 처리하다 보면 코드가 스파게티가 되는 건 시간문제야.

그래서 오늘은 Python의 정규표현식(Regular Expression)과 고급 문자열 조작 기법을 완전히 파헤쳐볼 거야.
처음엔 좀 낯설 수 있는데, 한 번 익히면 "이걸 왜 이제야 알았지?" 하는 순간이 반드시 온다고. 🔥

자, 준비됐어? 같이 달려보자!

📌 1. 정규표현식이 뭔데? — 기초 개념 완전 정리

정규표현식(Regular Expression, 줄여서 regex 또는 regexp)은 문자열에서 특정 패턴을 찾거나, 대체하거나, 추출하기 위한 특수한 문자 시퀀스야.
1950년대 수학자 스티븐 클레이니(Stephen Kleene)가 정규 언어를 표현하기 위해 개발한 개념인데, 지금은 거의 모든 프로그래밍 언어에서 지원해.

Python에서는 re 모듈을 통해 정규표현식을 사용할 수 있어. 표준 라이브러리에 포함되어 있으니까 별도 설치 없이 바로 쓸 수 있지!

🔧 re 모듈 임포트와 기본 사용법

Python에서 정규표현식을 쓰려면 먼저 re 모듈을 임포트해야 해. 아주 간단해!

import re

# 가장 기본적인 사용법
text = "Python은 정말 재미있는 언어야! 2024년에도 최고!"

# 숫자 찾기
result = re.search(r'\d+', text)
if result:
    print(result.group())  # 출력: 2024

# 모든 숫자 찾기
all_numbers = re.findall(r'\d+', text)
print(all_numbers)  # 출력: ['2024']

⚡ 4. re.compile() — 성능을 위한 패턴 컴파일

같은 패턴을 여러 번 사용한다면 re.compile()로 미리 컴파일해두는 게 훨씬 효율적이야!
패턴을 매번 파싱하는 오버헤드를 줄일 수 있거든. 실무에서 대용량 텍스트 처리할 때 특히 중요해.

import re
import time

# 컴파일 없이 사용
start = time.time()
text_list = ["이메일: user@example.com"] * 100000
for text in text_list:
    re.findall(r'[\w.-]+@[\w.-]+\.\w+', text)
print(f"컴파일 없이: {time.time() - start:.3f}초")

# 컴파일 후 사용
email_pattern = re.compile(r'[\w.-]+@[\w.-]+\.\w+')
start = time.time()
for text in text_list:
    email_pattern.findall(text)
print(f"컴파일 후: {time.time() - start:.3f}초")
# 컴파일 후가 훨씬 빠름!

# 컴파일된 패턴 객체의 메서드들
pattern = re.compile(r'(\d{4})-(\d{2})-(\d{2})')

# 동일한 메서드들을 사용할 수 있어
result = pattern.match("2024-01-15 오늘 날짜")
print(result.groups())  # ('2024', '01', '15')

result2 = pattern.findall("2024-01-15 ~ 2024-12-31")
print(result2)  # [('2024', '01', '15'), ('2024', '12', '31')]

🚩 플래그 (Flags) — 매칭 동작 제어

플래그를 사용하면 정규표현식의 동작 방식을 세밀하게 제어할 수 있어!

import re

# re.IGNORECASE (re.I) - 대소문자 무시
text = "Python python PYTHON"
result = re.findall(r'python', text, re.IGNORECASE)
print(result)  # ['Python', 'python', 'PYTHON']

# re.MULTILINE (re.M) - 여러 줄 모드 (^, $가 각 줄에 적용)
multiline_text = """첫 번째 줄
두 번째 줄
세 번째 줄"""

# MULTILINE 없이 - 전체 문자열의 시작만
result1 = re.findall(r'^\w+', multiline_text)
print(result1)  # ['첫']

# MULTILINE 있이 - 각 줄의 시작
result2 = re.findall(r'^\w+', multiline_text, re.MULTILINE)
print(result2)  # ['첫', '두', '세']

# re.DOTALL (re.S) - . 이 줄바꿈도 포함
text2 = "시작\n중간\n끝"
print(re.findall(r'시작.+끝', text2))           # []  ← . 이 \n 못 넘음
print(re.findall(r'시작.+끝', text2, re.DOTALL)) # ['시작\n중간\n끝']

# re.VERBOSE (re.X) - 주석과 공백 허용 (복잡한 패턴 가독성 향상!)
email_pattern = re.compile(r'''
    [\w.+-]+        # 로컬 파트 (사용자명)
    @               # @ 기호
    [\w-]+          # 도메인 이름
    (?:\.[\w-]+)*   # 서브도메인 (선택적)
    \.\w{2,}        # 최상위 도메인 (.com, .kr 등)
''', re.VERBOSE)

emails = ["user@example.com", "test.email+tag@sub.domain.co.kr"]
for email in emails:
    if email_pattern.match(email):
        print(f"✅ 유효한 이메일: {email}")

# 여러 플래그 조합 (| 사용)
pattern = re.compile(r'python', re.IGNORECASE | re.MULTILINE)

🛠️ 5. 실전 패턴 레시피 — 자주 쓰는 정규표현식 모음

이론은 충분히 배웠으니까, 이제 실제로 자주 쓰이는 패턴들을 모아봤어!
복붙해서 바로 쓸 수 있는 실용적인 레시피들이야. 🍳

import re

# ===== 실전 예제 모음 =====

# 1. 이메일 유효성 검사
def validate_email(email):
    pattern = re.compile(r'^[\w.+-]+@[\w-]+(?:\.[\w-]+)*\.\w{2,}$')
    return bool(pattern.match(email))

print(validate_email("user@example.com"))     # True
print(validate_email("invalid.email"))         # False
print(validate_email("test@sub.domain.co.kr")) # True

# 2. 전화번호 정규화
def normalize_phone(phone):
    # 숫자만 추출
    digits = re.sub(r'\D', '', phone)
    # 형식 적용
    if len(digits) == 11:  # 010-XXXX-XXXX
        return re.sub(r'(\d{3})(\d{4})(\d{4})', r'\1-\2-\3', digits)
    elif len(digits) == 10:  # 02-XXXX-XXXX 또는 0XX-XXX-XXXX
        return re.sub(r'(\d{2,3})(\d{3,4})(\d{4})', r'\1-\2-\3', digits)
    return phone

print(normalize_phone("010.1234.5678"))  # 010-1234-5678
print(normalize_phone("01012345678"))    # 010-1234-5678
print(normalize_phone("02-123-4567"))    # 02-123-4567

# 3. HTML 태그 제거
def strip_html(html_text):
    clean = re.sub(r'<[^>]+>', '', html_text)
    # 연속 공백 정리
    clean = re.sub(r'\s+', ' ', clean).strip()
    return clean

html = "<h1>제목</h1><p>이것은 <b>굵은</b> 텍스트입니다.</p>"
print(strip_html(html))  # "제목 이것은 굵은 텍스트입니다."

# 4. 개인정보 마스킹
def mask_personal_info(text):
    # 이메일 마스킹
    text = re.sub(r'([\w.+-]{2})[\w.+-]*(@[\w.-]+)', r'\1***\2', text)
    # 전화번호 마스킹
    text = re.sub(r'(\d{3})-(\d{4})-(\d{4})', r'\1-****-\3', text)
    return text

personal_text = "연락처: 010-1234-5678, 이메일: username@example.com"
print(mask_personal_info(personal_text))
# "연락처: 010-****-5678, 이메일: us***@example.com"

# 5. 한글만 추출
def extract_korean(text):
    return re.findall(r'[가-힣]+', text)

mixed = "Hello 안녕하세요 World 반갑습니다 123"
print(extract_korean(mixed))  # ['안녕하세요', '반갑습니다']

🔬 6. 고급 문자열 조작 — Python 내장 기능 완전 활용

정규표현식만이 답은 아니야! Python의 내장 문자열 메서드들도 엄청 강력하거든.
정규표현식과 내장 메서드를 적절히 조합하면 최강의 텍스트 처리가 가능해. 💪

🔄 str.translate() — 문자 단위 변환의 최강자

str.translate()는 문자 단위로 변환하거나 삭제할 때 정규표현식보다 훨씬 빠른 경우가 많아!

# str.maketrans() + str.translate() 조합
# 특수문자 제거
text = "Hello, World! How are you? I'm fine."

# 제거할 문자들 지정
remove_chars = ",.!?'"
table = str.maketrans('', '', remove_chars)
result = text.translate(table)
print(result)  # "Hello World How are you Im fine"

# 문자 치환
# 영어 소문자를 대문자로, 특수문자 제거
table2 = str.maketrans(
    'abcdefghijklmnopqrstuvwxyz',  # 변환 전
    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',  # 변환 후
    ',.!?'                          # 삭제할 문자
)
result2 = text.translate(table2)
print(result2)  # "HELLO WORLD HOW ARE YOU I'M FINE"

# 유니코드 활용 - 전각 문자를 반각으로
fullwidth = "ＡＢＣＤＥ１２３４５"
table3 = str.maketrans(
    ''.join(chr(0xFF01 + i) for i in range(94)),  # 전각 문자
    ''.join(chr(0x21 + i) for i in range(94))      # 반각 문자
)
print(fullwidth.translate(table3))  # "ABCDE12345"

✂️ 고급 슬라이싱과 문자열 분리

# 다양한 문자열 분리 기법

# partition() - 구분자 기준으로 3분할
text = "이름: 홍길동"
before, sep, after = text.partition(': ')
print(before)  # "이름"
print(sep)     # ": "
print(after)   # "홍길동"

# rpartition() - 오른쪽에서 첫 번째 구분자 기준
path = "/home/user/documents/file.txt"
dir_path, sep, filename = path.rpartition('/')
print(dir_path)   # "/home/user/documents"
print(filename)   # "file.txt"

# splitlines() - 줄 단위 분리
multiline = "첫 번째 줄\n두 번째 줄\r\n세 번째 줄\r네 번째 줄"
lines = multiline.splitlines()
print(lines)
# ['첫 번째 줄', '두 번째 줄', '세 번째 줄', '네 번째 줄']

# keepends=True로 줄바꿈 문자 유지
lines_with_ends = multiline.splitlines(keepends=True)
print(lines_with_ends)
# ['첫 번째 줄\n', '두 번째 줄\r\n', '세 번째 줄\r', '네 번째 줄']

# split() 고급 활용
csv_line = "홍길동,25,서울,개발자"
fields = csv_line.split(',')
print(fields)  # ['홍길동', '25', '서울', '개발자']

# maxsplit으로 분리 횟수 제한
limited = csv_line.split(',', maxsplit=2)
print(limited)  # ['홍길동', '25', '서울,개발자']

🎨 문자열 포매팅 고급 기법

# f-string 고급 활용 (Python 3.6+)
name = "홍길동"
score = 95.678
items = [1, 2, 3, 4, 5]

# 기본 포매팅
print(f"이름: {name}, 점수: {score:.2f}")  # "이름: 홍길동, 점수: 95.68"

# 정렬과 패딩
print(f"{'왼쪽':<10}|{'가운데':^10}|{'오른쪽':>10}")
# "왼쪽      |  가운데  |    오른쪽"

# 숫자 포매팅
big_num = 1234567890
print(f"{big_num:,}")        # "1,234,567,890"  (천 단위 구분)
print(f"{big_num:010d}")     # "1234567890"  (0 패딩)
print(f"{0.1234:.2%}")       # "12.34%"  (퍼센트)
print(f"{255:#010x}")        # "0x000000ff"  (16진수)
print(f"{255:#010b}")        # "0b011111111"  (2진수)

# 표현식 사용
print(f"합계: {sum(items)}, 평균: {sum(items)/len(items):.1f}")

# Python 3.8+ - = 디버깅 출력
x = 42
print(f"{x=}")  # "x=42"  ← 변수명과 값을 함께 출력!

# format() 메서드 고급 활용
template = "{name}님의 {subject} 점수는 {score:.1f}점입니다."
print(template.format(name="김철수", subject="수학", score=87.5))

# 딕셔너리 언패킹
data = {"name": "이영희", "subject": "영어", "score": 92.3}
print(template.format(**data))

🔍 문자열 검색과 분석

# 고급 문자열 검색 기법

text = "Python은 정말 강력한 언어야. Python을 배우면 뭐든 할 수 있어!"

# count() - 출현 횟수
print(text.count('Python'))    # 2
print(text.count('Python', 0, 20))  # 1  (범위 지정)

# find() vs index()
print(text.find('강력'))       # 10  (못 찾으면 -1 반환)
print(text.find('없는단어'))   # -1
# print(text.index('없는단어')) # ValueError 발생!

# rfind() - 오른쪽에서 검색
print(text.rfind('Python'))    # 마지막 Python의 위치

# startswith(), endswith() - 접두사/접미사 확인
print(text.startswith('Python'))   # True
print(text.endswith('있어!'))       # True

# 튜플로 여러 패턴 동시 확인
filenames = ["report.pdf", "data.csv", "image.png", "script.py"]
for f in filenames:
    if f.endswith(('.pdf', '.csv')):
        print(f"문서 파일: {f}")
# 문서 파일: report.pdf
# 문서 파일: data.csv

# 문자열 분석 메서드들
sample = "Hello World 123"
print(sample.isalpha())    # False (숫자 포함)
print(sample.isdigit())    # False (문자 포함)
print(sample.isalnum())    # False (공백 포함)
print("Hello".isalpha())   # True
print("12345".isdigit())   # True
print("Hello123".isalnum()) # True
print("  ".isspace())      # True
print("HELLO".isupper())   # True
print("hello".islower())   # True
print("Hello World".istitle()) # True

🚀 7. 실전 프로젝트 — 텍스트 처리 파이프라인 구축

이제 배운 것들을 종합해서 실제 프로젝트에서 쓸 수 있는 텍스트 처리 파이프라인을 만들어보자!
재능넷 같은 플랫폼에서 사용자 입력 데이터를 정제하는 시나리오를 예로 들어볼게. 😊

📊 로그 파일 분석기

import re
from collections import Counter, defaultdict
from datetime import datetime

class LogAnalyzer:
    """서버 로그 파일 분석기"""
    
    # 패턴 미리 컴파일 (성능 최적화)
    LOG_PATTERN = re.compile(
        r'(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+'
        r'(?P<level>DEBUG|INFO|WARNING|ERROR|CRITICAL)\s+'
        r'(?P<message>.+)',
        re.MULTILINE
    )
    IP_PATTERN = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
    URL_PATTERN = re.compile(r'https?://[\w.-]+(?:/[\w./?=%&-]*)?')
    
    def __init__(self, log_text):
        self.log_text = log_text
        self.entries = self._parse()
    
    def _parse(self):
        """로그 파싱"""
        entries = []
        for match in self.LOG_PATTERN.finditer(self.log_text):
            entries.append({
                'timestamp': match.group('timestamp'),
                'level': match.group('level'),
                'message': match.group('message').strip()
            })
        return entries
    
    def get_level_stats(self):
        """레벨별 통계"""
        return Counter(entry['level'] for entry in self.entries)
    
    def get_errors(self):
        """에러 로그만 추출"""
        return [e for e in self.entries if e['level'] in ('ERROR', 'CRITICAL')]
    
    def extract_ips(self):
        """모든 IP 주소 추출"""
        ips = []
        for entry in self.entries:
            ips.extend(self.IP_PATTERN.findall(entry['message']))
        return Counter(ips)
    
    def get_hourly_stats(self):
        """시간대별 로그 통계"""
        hourly = defaultdict(int)
        for entry in self.entries:
            hour = entry['timestamp'][11:13]  # HH 추출
            hourly[hour] += 1
        return dict(sorted(hourly.items()))
    
    def generate_report(self):
        """분석 리포트 생성"""
        level_stats = self.get_level_stats()
        errors = self.get_errors()
        top_ips = self.extract_ips().most_common(5)
        
        report = f"""
=== 로그 분석 리포트 ===
총 로그 수: {len(self.entries)}개

[레벨별 통계]
{chr(10).join(f'  {level}: {count}건' for level, count in level_stats.items())}

[에러 목록] ({len(errors)}건)
{chr(10).join(f'  [{e["timestamp"]}] {e["message"]}' for e in errors[:5])}

[상위 IP 주소]
{chr(10).join(f'  {ip}: {count}회' for ip, count in top_ips)}
"""
        return report.strip()


# 사용 예시
sample_log = """
2024-01-15 09:00:01 INFO 서버 시작 완료
2024-01-15 09:00:15 INFO 클라이언트 연결: 192.168.1.100
2024-01-15 09:01:23 WARNING 메모리 사용량 80% 초과
2024-01-15 09:02:45 ERROR 데이터베이스 연결 실패: 192.168.1.200
2024-01-15 09:03:12 INFO 재연결 시도 중...
2024-01-15 09:03:45 ERROR 타임아웃: 192.168.1.200
2024-01-15 09:05:00 INFO 연결 복구 완료
2024-01-15 10:00:00 CRITICAL 디스크 용량 부족: 192.168.1.100
"""

analyzer = LogAnalyzer(sample_log)
print(analyzer.generate_report())

🧹 텍스트 정제 파이프라인

import re
import unicodedata

class TextCleaner:
    """텍스트 정제 파이프라인"""
    
    def __init__(self):
        # 패턴 컴파일
        self._html_tag = re.compile(r'<[^>]+>')
        self._url = re.compile(r'https?://\S+|www\.\S+')
        self._email = re.compile(r'[\w.+-]+@[\w-]+\.\w+')
        self._phone = re.compile(r'\d{2,3}[-.]?\d{3,4}[-.]?\d{4}')
        self._whitespace = re.compile(r'\s+')
        self._special_chars = re.compile(r'[^\w\s가-힣.,!?]')
        self._repeated_chars = re.compile(r'(.)\1{2,}')  # 3회 이상 반복
        self._emoticons = re.compile(
            r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF'
            r'\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF]+'
        )
    
    def remove_html(self, text):
        """HTML 태그 제거"""
        return self._html_tag.sub(' ', text)
    
    def remove_urls(self, text):
        """URL 제거"""
        return self._url.sub('[URL]', text)
    
    def mask_personal_info(self, text):
        """개인정보 마스킹"""
        text = self._email.sub('[이메일]', text)
        text = self._phone.sub('[전화번호]', text)
        return text
    
    def normalize_whitespace(self, text):
        """공백 정규화"""
        return self._whitespace.sub(' ', text).strip()
    
    def normalize_unicode(self, text):
        """유니코드 정규화 (전각→반각 등)"""
        return unicodedata.normalize('NFKC', text)
    
    def reduce_repeated_chars(self, text):
        """반복 문자 축소 (ㅋㅋㅋㅋ → ㅋㅋ)"""
        return self._repeated_chars.sub(r'\1\1', text)
    
    def remove_emoticons(self, text):
        """이모티콘 제거"""
        return self._emoticons.sub('', text)
    
    def clean(self, text, 
              remove_html=True,
              remove_urls=True, 
              mask_personal=True,
              normalize_ws=True,
              normalize_unicode=True,
              reduce_repeated=True):
        """전체 정제 파이프라인"""
        if normalize_unicode:
            text = self.normalize_unicode(text)
        if remove_html:
            text = self.remove_html(text)
        if remove_urls:
            text = self.remove_urls(text)
        if mask_personal:
            text = self.mask_personal_info(text)
        if reduce_repeated:
            text = self.reduce_repeated_chars(text)
        if normalize_ws:
            text = self.normalize_whitespace(text)
        return text


# 사용 예시
cleaner = TextCleaner()

dirty_text = """
<h1>안녕하세요!!!</h1>
<p>저는 홍길동입니다ㅋㅋㅋㅋㅋ</p>
연락처: 010-1234-5678
이메일: hong@example.com
참고: https://www.example.com/page
"""

clean_text = cleaner.clean(dirty_text)
print(clean_text)
# "안녕하세요!! 저는 홍길동입니다ㅋㅋ 연락처: [전화번호] 이메일: [이메일] 참고: [URL]"

⚡ 8. 성능 최적화 — 빠른 텍스트 처리의 비결

대용량 텍스트를 처리할 때는 성능이 정말 중요해!
같은 결과를 내더라도 방법에 따라 속도 차이가 수십 배까지 날 수 있거든. 🏎️

import re
import time

# 성능 테스트 예시

# 나쁜 예: 루프 안에서 매번 패턴 컴파일
def bad_approach(texts):
    results = []
    for text in texts:
        result = re.sub(r'\s+', ' ', text)  # 매번 컴파일!
        results.append(result)
    return results

# 좋은 예: 미리 컴파일
whitespace_pattern = re.compile(r'\s+')
def good_approach(texts):
    return [whitespace_pattern.sub(' ', text) for text in texts]

# 더 좋은 예: 단순 치환은 str.replace()가 더 빠를 수 있음
def best_approach_simple(texts):
    return [' '.join(text.split()) for text in texts]

# 문자열 결합 - 절대 + 연산자로 루프 돌리지 마!
# 나쁜 예
def bad_concat(words):
    result = ""
    for word in words:
        result += word + " "  # O(n²) 복잡도!
    return result.strip()

# 좋은 예
def good_concat(words):
    return " ".join(words)  # O(n) 복잡도!

# 성능 차이 확인
words = ["Python"] * 10000

start = time.time()
bad_concat(words)
print(f"+ 연산자: {time.time() - start:.4f}초")

start = time.time()
good_concat(words)
print(f"join(): {time.time() - start:.4f}초")
# join()이 수십 배 빠름!

🎯 성능 최적화 핵심 원칙

🌟 9. 고급 기법 — 알면 레벨업 되는 것들

🔄 조건부 패턴 (Conditional Patterns)

import re

# (?(id)yes|no) - 그룹 id가 매칭됐으면 yes 패턴, 아니면 no 패턴
# 예: 따옴표가 있으면 따옴표로 끝나야 하고, 없으면 그냥 단어

pattern = re.compile(r'("?)(\w+)(?(1)"|)')
# 그룹 1("?)이 매칭됐으면(따옴표 있으면) 끝에 "가 와야 함

test_cases = ['"hello"', 'world', '"python']
for test in test_cases:
    match = pattern.fullmatch(test)
    print(f"'{test}': {'매칭' if match else '불일치'}")
# '"hello"': 매칭
# 'world': 매칭
# '"python': 불일치  ← 시작 따옴표는 있는데 끝 따옴표가 없음!

🔁 원자적 그룹과 소유적 수량자

import re

# Python의 re 모듈은 원자적 그룹을 직접 지원하지 않지만
# regex 모듈(pip install regex)을 사용하면 가능해

# pip install regex
import regex  # 설치 필요

# 소유적 수량자 (Possessive Quantifier) - 백트래킹 없음
# 일반: r'\d+\b'  vs  소유적: r'\d++\b'
text = "12345abc"

# 일반 수량자 - 백트래킹 발생
result1 = re.search(r'\d+\b', text)
print(result1)  # None (백트래킹으로 시도하지만 실패)

# 원자적 그룹 - 백트래킹 없음 (regex 모듈)
result2 = regex.search(r'(?>\d+)\b', text)
print(result2)  # None (더 빠르게 실패)

📝 정규표현식 디버깅 — regex101 스타일

import re

def debug_regex(pattern, text, flags=0):
    """정규표현식 디버깅 도우미"""
    try:
        compiled = re.compile(pattern, flags)
        matches = list(compiled.finditer(text))
        
        print(f"패턴: {pattern}")
        print(f"텍스트: {text}")
        print(f"매칭 수: {len(matches)}개")
        print("-" * 50)
        
        for i, match in enumerate(matches, 1):
            print(f"매칭 {i}:")
            print(f"  전체: '{match.group()}'")
            print(f"  위치: {match.span()}")
            
            if match.lastindex:
                for j in range(1, match.lastindex + 1):
                    print(f"  그룹 {j}: '{match.group(j)}'")
            
            if match.groupdict():
                for name, value in match.groupdict().items():
                    print(f"  {name}: '{value}'")
        
        # 매칭 시각화
        print("\n시각화:")
        result = list(text)
        for match in reversed(matches):
            start, end = match.span()
            result.insert(end, '】')
            result.insert(start, '【')
        print(''.join(result))
        
    except re.error as e:
        print(f"패턴 오류: {e}")

# 사용 예시
debug_regex(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
    "오늘은 2024-01-15이고 내일은 2024-01-16입니다."
)

🌐 유니코드와 다국어 처리

import re
import unicodedata

# 유니코드 카테고리를 이용한 문자 분류
def categorize_chars(text):
    categories = {}
    for char in text:
        cat = unicodedata.category(char)
        cat_name = {
            'Lu': '대문자', 'Ll': '소문자', 'Nd': '숫자',
            'Zs': '공백', 'Po': '구두점', 'Lo': '기타문자(한글등)'
        }.get(cat, cat)
        categories[cat_name] = categories.get(cat_name, 0) + 1
    return categories

text = "Hello 안녕 123 !@#"
print(categorize_chars(text))

# 유니코드 속성을 이용한 패턴 (regex 모듈)
# import regex
# 한글, 일본어, 중국어 등 모든 아시아 문자
# pattern = regex.compile(r'\p{Han}+')  # 한자
# pattern = regex.compile(r'\p{Hangul}+')  # 한글
# pattern = regex.compile(r'\p{Hiragana}+')  # 히라가나

# 표준 re 모듈로 다국어 처리
# 한글: [가-힣] 또는 [\uAC00-\uD7A3]
# 일본어 히라가나: [\u3040-\u309F]
# 일본어 가타카나: [\u30A0-\u30FF]
# 한자: [\u4E00-\u9FFF]

multilingual = "Hello 안녕 こんにちは 你好 مرحبا"

korean = re.findall(r'[가-힣]+', multilingual)
japanese = re.findall(r'[\u3040-\u30FF]+', multilingual)
chinese = re.findall(r'[\u4E00-\u9FFF]+', multilingual)

print(f"한국어: {korean}")    # ['안녕']
print(f"일본어: {japanese}")  # ['こんにちは']
print(f"중국어: {chinese}")   # ['你好']

# 유니코드 정규화
# NFC: 조합형 (한글 완성형)
# NFD: 분해형 (한글 자모 분리)
# NFKC: 호환성 조합형 (전각→반각 등)
# NFKD: 호환성 분해형

text_with_fullwidth = "ＡＢＣＤ１２３４"
normalized = unicodedata.normalize('NFKC', text_with_fullwidth)
print(normalized)  # "ABCD1234"  (전각→반각 변환)

📚 10. 자주 하는 실수와 주의사항

정규표현식을 쓰다 보면 누구나 한 번씩 빠지는 함정들이 있어.
미리 알아두면 삽질을 줄일 수 있어! 😅

import re

html = "<b>첫 번째</b> 텍스트 <b>두 번째</b>"

# 잘못된 방법 - 탐욕적 매칭
wrong = re.findall(r'<b>.+</b>', html)
print(wrong)  # ['<b>첫 번째</b> 텍스트 <b>두 번째</b>']  ← 전체를 하나로!

# 올바른 방법 - 비탐욕적 매칭
correct = re.findall(r'<b>.+?</b>', html)
print(correct)  # ['<b>첫 번째</b>', '<b>두 번째</b>']  ← 각각 따로!

import re

# 잘못된 방법 - raw string 미사용
# \d는 파이썬 문자열에서 그냥 d로 처리될 수 있음
try:
    result = re.findall('\d+', "abc123")  # 이건 우연히 작동함
    result2 = re.findall('\b\w+\b', "hello world")  # \b가 백스페이스로!
    print(result2)  # 예상과 다른 결과
except:
    pass

# 올바른 방법 - raw string 사용
result = re.findall(r'\d+', "abc123")       # ['123']
result2 = re.findall(r'\b\w+\b', "hello world")  # ['hello', 'world']
print(result2)

import re

text = "오늘은 2024년 1월 15일입니다"

# match는 처음부터 매칭 - 숫자로 시작하지 않으니 None!
result_match = re.match(r'\d+', text)
print(result_match)  # None

# search는 전체 탐색 - 중간의 숫자도 찾음
result_search = re.search(r'\d+', text)
print(result_search.group())  # '2024'

# 전체 문자열이 패턴과 일치하는지 확인하려면 fullmatch() 사용
print(re.fullmatch(r'\d{4}', "2024"))   # 매칭
print(re.fullmatch(r'\d{4}', "20245"))  # None (길이 다름)

import re

# 너무 단순한 이메일 패턴 - 많은 유효한 이메일을 놓침
simple_pattern = r'\w+@\w+\.\w+'
# test+tag@example.com  ← + 기호 때문에 실패!
# user@sub.domain.com   ← 서브도메인 때문에 실패!

# 더 나은 패턴
better_pattern = r'[\w.+-]+@[\w-]+(?:\.[\w-]+)*\.\w{2,}'

test_emails = [
    "user@example.com",
    "test+tag@example.com",
    "user@sub.domain.co.kr",
    "user.name@example.org"
]

for email in test_emails:
    simple = bool(re.match(r'^\w+@\w+\.\w+$', email))
    better = bool(re.match(r'^[\w.+-]+@[\w-]+(?:\.[\w-]+)*\.\w{2,}$', email))
    print(f"{email}: 단순={simple}, 개선={better}")

# 정규표현식이 항상 최선은 아니야!

# 나쁜 예: 단순 포함 여부 확인에 정규표현식 사용
import re
text = "Hello World"
if re.search(r'World', text):  # 오버킬!
    print("있음")

# 좋은 예: 단순 포함 여부는 in 연산자
if 'World' in text:
    print("있음")

# 나쁜 예: 단순 치환에 정규표현식 사용
result = re.sub(r'Hello', 'Hi', text)  # 오버킬!

# 좋은 예: 단순 치환은 str.replace()
result = text.replace('Hello', 'Hi')

# 정규표현식이 필요한 경우:
# - 패턴이 복잡할 때 (이메일, URL, 날짜 형식 등)
# - 여러 패턴을 동시에 처리할 때
# - 그룹 캡처가 필요할 때
# - 동적 패턴이 필요할 때