Regex ב-Python: המודול re, תבניות, קבוצות והחלפה

מתי להשתמש ב-Regex

ביטויים רגולריים הם שפה קטנה לתיאור תבניות טקסט. הם חזקים, וקל להשתמש בהם יותר מדי.

לפני שפונים ל-re, שאלו אם מתודות מחרוזת רגילות יספיקו. .split(), .replace(), .startswith(), "target" in text: הן מהירות יותר, קריאות יותר ופחות מועדות לשגיאות מה-regex המקביל. שמרו את ה-regex למקרים שבהם התבנית שחשובה לכם באמת מובנית, אבל גמישה מדי לפעולות מחרוזת קבועות: כתובות אימייל, מספרי טלפון, שורות לוג עם צורה ידועה, קטעי HTML או Markdown, כל חיפוש של "מצא דבר מהסוג הזה".

אוצר המילים הבסיסי

תבנית regex היא מחרוזת שמתארת את מה שאתם מחפשים. כמה אבני בניין:

• .: כל תו בודד
• \d: כל ספרה (0 עד 9)
• \w: כל תו "מילה" (אות, ספרה, קו תחתון)
• \s: כל תו רווח לבן
• ^: תחילת המחרוזת
• $: סוף המחרוזת
• [abc]: אחד מ-a, b או c
• [^abc]: כל תו חוץ מ-a, b, c
• a|b: a או b
• *: אפס או יותר מהדבר הקודם
• +: אחד או יותר
• ?: אפס או אחד
• {3}: בדיוק 3
• {2,5}: בין 2 ל-5
• ( ... ): קבוצה (לוכדת את ההתאמה שבפנים)

זה מספיק לרוב הביטויים הרגולריים בעולם האמיתי.

הפונקציות המרכזיות

re.search(pattern, text) מוצאת את ההתאמה הראשונה בכל מקום במחרוזת. היא מחזירה אובייקט התאמה או None:

import re

text = "Order 12345 shipped on 2026-04-20"
match = re.search(r"\d{5}", text)

if match:
    print("Found:", match.group())
    print("Position:", match.start(), "-", match.end())
else:
    print("No match")

תמיד השתמשו ב-raw string (r"...") לתבניות regex. אחרת Python מנסה לפרש את הלוכסנים ההפוכים כרצפי escape של מחרוזת, ומקבלים תבנית שונה ממה שהקלדתם.

re.match(pattern, text) דומה ל-search, אבל מתאימה רק בהתחלה:

import re

print(re.search(r"hello", "say hello"))   # match
print(re.match(r"hello", "say hello"))    # None: המחרוזת לא התחילה ב-hello

ברוב המקרים רוצים את search.

re.findall(pattern, text) מחזירה את כל ההתאמות שאינן חופפות, כרשימה:

import re

text = "Apples 3, oranges 12, pears 7"
numbers = re.findall(r"\d+", text)
print(numbers)   # ['3', '12', '7']

שימו לב ש-findall מחזירה מחרוזות, לא אובייקטי התאמה. אם בתבנית יש קבוצה אחת, מקבלים בחזרה את תוכן הקבוצה. עם כמה קבוצות, מקבלים רשימה של tuples.

קבוצות לכידה

סוגריים בתבנית לוכדים את מה שהותאם בתוכם:

import re

line = "2026-04-20: server started"
match = re.search(r"(\d{4})-(\d{2})-(\d{2}): (.+)", line)

if match:
    print(match.group(0))  # כל ההתאמה
    print(match.group(1))  # '2026': הקבוצה הראשונה
    print(match.group(2))  # '04'
    print(match.group(3))  # '20'
    print(match.group(4))  # 'server started'
    print(match.groups())  # tuple של כל הקבוצות

קבוצות עם שם בדרך כלל ברורות יותר:

import re

line = "2026-04-20: server started"
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}): (?P<msg>.+)"
match = re.search(pattern, line)

if match:
    print(match["year"], match["month"], match["day"])
    print(match.groupdict())

ברגע שיש ב-regex יותר מקבוצה אחת, מתן שמות לקבוצות הופך את קוד החילוץ לקל הרבה יותר למעקב.

החלפה עם re.sub

re.sub(pattern, replacement, text) מחליפה כל התאמה:

import re

text = "Call me at (415) 555-1234 or 212.555.5678"
cleaned = re.sub(r"[^\d]", "", text)
print(cleaned)

זה מסיר כל מה שאינו ספרה. ההחלפה יכולה להפנות לקבוצות שנלכדו עם \1, \2 וכן הלאה, או ב-raw strings, \g<1> ברור יותר:

import re

text = "Alice Johnson, Bob Smith, Carol Tran"
swapped = re.sub(r"(\w+) (\w+)", r"\2, \1", text)
print(swapped)

אפשר גם להעביר פונקציה כהחלפה. זה שימושי להמרות שאינן החלפה פשוטה:

import re

text = "Prices: 10, 20, 30"
doubled = re.sub(r"\d+", lambda m: str(int(m.group()) * 2), text)
print(doubled)

הידור תבניות לשימוש חוזר

אם אתם משתמשים באותה תבנית פעמים רבות, במיוחד בלולאה, הדרו (compile) אותה פעם אחת:

import re

DATE = re.compile(r"\d{4}-\d{2}-\d{2}")

lines = [
    "started at 2026-04-20",
    "no timestamp here",
    "finished 2026-04-21",
]

for line in lines:
    match = DATE.search(line)
    if match:
        print(match.group())

תבניות מהודרות חושפות את אותן מתודות, search, match, findall, sub, בלי התבנית כארגומנט הראשון. מעט יעילות יותר, ולעיתים קרובות קריאות יותר.

דגלים (Flags)

משנים נפוצים, שמועברים כארגומנט flags= או משולבים יחד עם OR:

• re.IGNORECASE (re.I): התאמה שאינה רגישה לאותיות גדולות וקטנות.
• re.MULTILINE (re.M): ^ ו-$ מתאימים בכל שורה, לא רק בגבולות המחרוזת.
• re.DOTALL (re.S): . מתאים גם לתווי שורה חדשה (כברירת מחדל הוא לא).
• re.VERBOSE (re.X): מאפשר רווחים והערות # בתוך התבנית, לשיפור הקריאוּת.

import re

text = "HELLO world"
print(re.search(r"hello", text))
print(re.search(r"hello", text, re.IGNORECASE))

re.VERBOSE שימושי במיוחד לתבניות מורכבות:

import re

pattern = re.compile(r"""
    (?P<user>[\w.]+)    # חלק שם המשתמש
    @                    # סימן @ מילולי
    (?P<domain>[\w.-]+)  # הדומיין
""", re.VERBOSE)

match = pattern.search("Contact me at rosa@example.com")
if match:
    print(match.groupdict())

ביטויים רגולריים בכמה שורות ועם הערות קלים לתחזוקה הרבה יותר משורות אחת אטומות.

Greedy לעומת Lazy

כמתים (*, +, ?, {n,}) הם חמדנים (greedy) כברירת מחדל: הם מתאימים כמה שיותר. הוסיפו ? כדי להפוך אותם ל_עצלים_ (lazy):

import re

html = "<b>bold</b> and <i>italic</i>"

# Greedy: מתאים מה-< הראשון ועד ה-> האחרון
print(re.findall(r"<.+>", html))

# Lazy: מתאים כל תגית בנפרד
print(re.findall(r"<.+?>", html))

הגרסה החמדנית לוכדת את כל תת-המחרוזת מ-<b> ועד </i>, וכנראה שזה לא מה שרציתם. ה-.+? העצל עוצר ב-> הראשון.

(הערת אגב: אל תפענחו HTML עם regex בסביבת ייצור. השתמשו ב-html.parser או ב-BeautifulSoup. הדוגמה שלמעלה נועדה רק להמחיש חמדנות.)

דוגמה מציאותית

פענוח שורות מפורמט לוג פשוט:

import re

log = """
2026-04-20 09:00:12 INFO  Server started
2026-04-20 09:01:45 WARN  Slow query detected
2026-04-20 09:03:01 ERROR Database connection lost
"""

pattern = re.compile(r"""
    (?P<date>\d{4}-\d{2}-\d{2})\s+
    (?P<time>\d{2}:\d{2}:\d{2})\s+
    (?P<level>INFO|WARN|ERROR)\s+
    (?P<message>.+)
""", re.VERBOSE)

for line in log.strip().splitlines():
    match = pattern.match(line)
    if match:
        print(match.groupdict())

הרבה כוח בלא הרבה שורות.

כמה הרגלים

• תמיד השתמשו ב-raw strings לתבניות.
• התחילו בתבנית הפשוטה ביותר שעובדת, והדקו אותה אחר כך.
• השתמשו בקבוצות עם שם ברגע שיש יותר מקבוצה אחת.
• הדרו תבניות שתשתמשו בהן שוב.
• regex איטי יותר ממתודות מחרוזת רגילות. אם .split() מספיקה, השתמשו ב-.split().

הצעד הבא: שגיאות ודיבאגינג

בזה מסתיים הסיור בנתונים אמיתיים: קבצים, JSON, CSV, HTTP, תאריכים ו-regex. אבל כל תוכנית אמיתית נתקלת במוקדם או במאוחר בשגיאה, וקריאה טובה של tracebacks של Python היא מיומנות הדיבאגינג החשובה ביותר שאפשר לרכוש. הפרק האחרון מסביר חריגות ואת השגיאות הספציפיות שתיתקלו בהן הכי הרבה.