re — ביטויים רגולריים פשוטים

מודול זה מממש פעולות של ביטויים רגולריים. תחביר הביטויים הרגולריים הנתמך הוא תת-קבוצה של מודול re של CPython (ולמעשה הוא תת-קבוצה של ביטויים רגולריים מורחבים של POSIX).

האופרטורים והרצפים המיוחדים הנתמכים הם:

.

התאמה לכל תו שהוא.

[...]

התאמה לקבוצת תווים. נתמכים תווים בודדים וטווחים, כולל קבוצות שלילה (לדוגמה [^a-c]).

^

התאמה לתחילת המחרוזת.

$

התאמה לסוף המחרוזת.

?

התאמה לאפס או למופע אחד של התת-תבנית הקודמת.

*

התאמה לאפס מופעים או יותר של התת-תבנית הקודמת.

+

התאמה למופע אחד או יותר של התת-תבנית הקודמת.

??

גרסה לא-חמדנית של ?, התאמה לאפס או לאחד, עם העדפה לאפס.

*?

גרסה לא-חמדנית של *, התאמה לאפס או יותר, עם העדפה להתאמה הקצרה ביותר.

+?

גרסה לא-חמדנית של +, התאמה לאחד או יותר, עם העדפה להתאמה הקצרה ביותר.

|

התאמה לתת-תבנית שמשמאל לאופרטור זה או לזו שמימינו.

(...)

קיבוץ. כל קבוצה היא קבוצה לוכדת (ניתן לגשת לתת-המחרוזת שהיא לוכדת באמצעות המתודה match.group()).

(?:...)

קיבוץ לא-לוכד. כל קבוצה מותאמת לפי אותם כללים כמו קיבוץ רגיל, אך לא תהיה חלק מאובייקט ההתאמה.

\d

מתאים לספרה. שקול ל-[0-9].

\D

מתאים לתו שאינו ספרה. שקול ל-[^0-9].

\s

מתאים לרווח לבן. שקול ל-[ \t-\r].

\S

מתאים לתו שאינו רווח לבן. שקול ל-[^ \t-\r].

\w

מתאים ל“תווי מילה“ (ASCII בלבד). שקול ל-[A-Za-z0-9_].

\W

מתאים לתווים שאינם ”תווי מילה“ (ASCII בלבד). שקול ל-[^A-Za-z0-9_].

\

תו בריחה (escape). כל תו אחר הבא אחרי הלוכסן ההפוך, מלבד אלה שצוינו לעיל, נלקח כפשוטו. לדוגמה, \* שקול ל-* כתו מילולי (ולא מטופל כאופרטור *). שים לב ש-\r, \n וכדומה אינם מטופלים באופן מיוחד, ויהיו שקולים לאותיות המילוליות r, n וכדומה. עקב כך, לא מומלץ להשתמש במחרוזות Python גולמיות (r"") עבור ביטויים רגולריים. לדוגמה, r"\r\n" כאשר משתמשים בו כביטוי רגולרי שקול ל-"rn". כדי להתאים לתו CR ואחריו LF, השתמש ב-"\r\n".

לא נתמך:

• חזרות ספורות ({m,n})

• קבוצות בעלות שם ((?P<name>...))

• טענות (assertions) מתקדמות יותר (\b, \B)

• תווי בריחה מיוחדים כמו \r, \n - השתמש במקום זאת במנגנון הבריחה של Python עצמו

• וכדומה.

דוגמה:

import re

# As re doesn't support escapes itself, use of r"" strings is not
# recommended.
regex = re.compile("[\r\n]")

regex.split("line1\rline2\nline3\r\n")

# Result:
# ['line1', 'line2', 'line3', '', '']

פונקציות

re.compile(regex_str: str, flags: int = 0) → 'regex'

הידור הביטוי הרגולרי, מחזיר אובייקט regex.

re.search(regex_str: str, string: str) → 'match | None'

הידור regex_str וחיפושו ב-string. בניגוד ל-match, פעולה זו תחפש במחרוזת את המיקום הראשון שמתאים לביטוי הרגולרי (שעדיין עשוי להיות 0 אם הביטוי הרגולרי מעוגן).

re.sub(regex_str: str, replace: str | Callable, string: str, count: int = 0, flags: int = 0, /) → str

הידור regex_str וחיפושו ב-string, החלפת כל ההתאמות ב-replace, והחזרת המחרוזת החדשה.

replace יכול להיות מחרוזת או פונקציה. אם זו מחרוזת, ניתן להשתמש ברצפי בריחה מהצורה \<number> ו-\g<number> כדי להתרחב לקבוצה המתאימה (או למחרוזת ריקה עבור קבוצות שלא הותאמו). אם replace היא פונקציה, היא חייבת לקבל ארגומנט יחיד (ההתאמה) ולהחזיר מחרוזת חלופית.

אם count מצוין ושונה מאפס, ההחלפה תיעצר לאחר שבוצע מספר זה של החלפות. הארגומנט flags מתעלמים ממנו.

אובייקטי Regex

ביטוי רגולרי מהודר. מופעים של מחלקה זו נוצרים באמצעות re.compile().

class re.regex

אובייקט ביטוי רגולרי מהודר המוחזר על ידי re.compile().

match(string: str, pos: int = 0, endpos: int | None = None) → 'match | None'

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

הפרמטר האופציונלי pos נותן אינדקס ב-string שבו החיפוש יתחיל; ערך ברירת המחדל שלו הוא 0. זה אינו שקול לחלוטין לחיתוך המחרוזת; תו התבנית '^' מתאים בתחילתה האמיתית של המחרוזת ובמיקומים מיד לאחר תו שורה חדשה, אך לאו דווקא באינדקס שבו החיפוש אמור להתחיל.

הפרמטר האופציונלי endpos מגביל עד כמה רחוק string נסרק; זה יהיה כאילו אורך המחרוזת הוא endpos תווים, כך שרק התווים מ-pos עד endpos - 1 נסרקים. אם endpos הוא None (ברירת המחדל), כל המחרוזת נסרקת.

search(string: str, pos: int = 0, endpos: int | None = None) → 'match | None'

סריקת string בחיפוש אחר המיקום הראשון שבו ביטוי רגולרי מהודר זה מפיק התאמה, והחזרת אובייקט match, או None אם אף מיקום אינו מתאים. זוהי המקבילה לתבנית מהודרת של הפונקציה search() ברמת המודול, והיא יעילה הרבה יותר כאשר אותה תבנית מוחלת על מחרוזות מרובות.

הפרמטר האופציונלי pos נותן אינדקס ב-string שבו החיפוש יתחיל; ערך ברירת המחדל שלו הוא 0. זה אינו שקול לחלוטין לחיתוך המחרוזת; תו התבנית '^' מתאים בתחילתה האמיתית של המחרוזת ובמיקומים מיד לאחר תו שורה חדשה, אך לאו דווקא באינדקס שבו החיפוש אמור להתחיל.

הפרמטר האופציונלי endpos מגביל עד כמה רחוק string נסרק; זה יהיה כאילו אורך המחרוזת הוא endpos תווים, כך שרק התווים מ-pos עד endpos - 1 נסרקים. אם endpos הוא None (ברירת המחדל), כל המחרוזת נסרקת.

sub(replace: str | Callable, string: str, count: int = 0, flags: int = 0, /) → str

חיפוש ביטוי רגולרי מהודר זה ב-string, החלפת כל ההתאמות ב-replace, והחזרת המחרוזת החדשה. זוהי המקבילה לתבנית מהודרת של הפונקציה sub() ברמת המודול, והיא יעילה הרבה יותר כאשר אותה תבנית מוחלת על מחרוזות מרובות.

replace יכול להיות מחרוזת או פונקציה. אם זו מחרוזת, ניתן להשתמש ברצפי בריחה מהצורה \<number> ו-\g<number> כדי להתרחב לקבוצה המתאימה (או למחרוזת ריקה עבור קבוצות שלא הותאמו). אם replace היא פונקציה, היא חייבת לקבל ארגומנט יחיד (ההתאמה) ולהחזיר מחרוזת חלופית.

אם count מצוין ושונה מאפס, ההחלפה תיעצר לאחר שבוצע מספר זה של החלפות. הארגומנט flags מתעלמים ממנו.

split(string: str, max_split: int = -1, /) → List[str]

פיצול string באמצעות ביטוי רגולרי. אם max_split ניתן, הוא מציין את מספר הפיצולים המרבי לביצוע. מחזיר רשימה של מחרוזות (ייתכנו עד max_split+1 רכיבים אם הוא מצוין).

אובייקטי התאמה

אובייקט התאמה מחזיק את תוצאת ההתאמה המוצלחת.

class re.match(regex_str: str, string: str)

התאמת regex_str מול string, מעוגנת בתחילת המחרוזת, והחזרת אובייקט התאמה, או None אם אין התאמה. זהו קיצור הדרך ברמת המודול: re.match(regex_str, string) שקול ל-re.compile(regex_str).match(string).

אותו אובייקט התאמה מוחזר גם על ידי search(), על ידי המתודות של התבנית המהודרת regex.match() / regex.search(), ומועבר לפונקציית ההחלפה שבה משתמש sub().

group(index: int) → str

מחזיר את (תת-)המחרוזת התואמת. index הוא 0 עבור ההתאמה המלאה, 1 ומעלה עבור כל קבוצה לוכדת. נתמכות רק קבוצות מספריות.