חשיפת המנוע: צלילה עמוקה לאלגוריתמי התאמת תבניות Regex בפייתון

ביטויים רגולריים, או regex, הם אבן יסוד בפיתוח תוכנה מודרני. עבור אינספור מתכנתים ברחבי העולם, הם הכלי המועדף לעיבוד טקסט, אימות נתונים וניתוח לוגים. אנו משתמשים בהם כדי למצוא, להחליף ולחלץ מידע בדיוק ששיטות מחרוזת פשוטות אינן יכולות להשתוות לו. עם זאת, עבור רבים, מנוע ה-regex נשאר קופסה שחורה – כלי קסום שמקבל תבנית סתומה ומחרוזת, ובדרך כלשהי מפיק תוצאה. חוסר הבנה זה עלול להוביל לקוד לא יעיל, ובמקרים מסוימים, לבעיות ביצועים קטסטרופליות.

מאמר זה מסיר את הלוט מעל מודול ה-re של פייתון. נצא למסע אל ליבת מנוע התאמת התבניות שלו, ונחקור את האלגוריתמים הבסיסיים המפעילים אותו. על ידי הבנה כיצד המנוע פועל, תוכלו לכתוב ביטויים רגולריים יעילים, חזקים וצפויים יותר, ולהפוך את השימוש שלכם בכלי רב עוצמה זה מניחושים למדע.

ליבת הביטויים הרגולריים: מהו מנוע Regex?

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

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

• מנועים מכווני טקסט (מבוססי DFA): מנועים אלה, המבוססים על אוטומטים סופיים דטרמיניסטיים (DFA), מעבדים את מחרוזת הקלט תו אחר תו. הם מהירים להפליא ומספקים ביצועים צפויים, בזמן ליניארי. הם לעולם אינם צריכים לבצע backtracking או להעריך מחדש חלקים מהמחרוזת. עם זאת, מהירות זו באה על חשבון תכונות; מנועי DFA אינם יכולים לתמוך במבנים מתקדמים כמו backreferences או quantifiers עצלים (lazy quantifiers). כלים כמו `grep` ו-`lex` משתמשים לרוב במנועים מבוססי DFA.
• מנועים מכווני Regex (מבוססי NFA): מנועים אלה, המבוססים על אוטומטים סופיים אי-דטרמיניסטיים (NFA), מונעים על ידי התבנית. הם נעים לאורך התבנית, ומנסים להתאים את רכיביה מול המחרוזת. גישה זו גמישה וחזקה יותר, תומכת במגוון רחב של תכונות כולל קבוצות לכידה, backreferences ו-lookarounds. רוב שפות התכנות המודרניות, כולל פייתון, פרל, ג'אווה וג'אווהסקריפט, משתמשות במנועי NFA.

מודול ה-re של פייתון משתמש במנוע NFA מסורתי המבוסס על מנגנון מכריע הנקרא backtracking. בחירת עיצוב זו היא המפתח הן לעוצמתו והן לסיכוני הביצועים הפוטנציאליים שלו.

סיפורם של שני אוטומטים: NFA מול DFA

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

אוטומטים סופיים דטרמיניסטיים (DFA): הנתיב הבלתי מתפשר

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

• כיצד זה עובד: מנוע מבוסס DFA בונה מכונת מצבים שבה כל מצב מייצג קבוצה של מיקומים אפשריים בתבנית ה-regex. הוא מעבד את מחרוזת הקלט משמאל לימין. לאחר קריאת כל תו, הוא מעדכן את מצבו הנוכחי בהתבסס על טבלת מעברים דטרמיניסטית. אם הוא מגיע לסוף המחרוזת כאשר הוא במצב "קבלת", ההתאמה מוצלחת.
• חוזקות:
  • מהירות: DFAs מעבדים מחרוזות בזמן ליניארי, O(n), כאשר n הוא אורך המחרוזת. מורכבות התבנית אינה משפיעה על זמן החיפוש.
  • צפויות: הביצועים עקביים ולעולם אינם יורדים לזמן אקספוננציאלי.
• חולשות:
  • תכונות מוגבלות: האופי הדטרמיניסטי של DFAs הופך את היישום של תכונות הדורשות זיכרון של התאמה קודמת לבלתי אפשרי, כגון backreferences (לדוגמה, (\w+)\s+\1). גם lazy quantifiers ו-lookarounds בדרך כלל אינם נתמכים.
  • פיצוץ מצבים: הידור תבנית מורכבת ל-DFA יכול לפעמים להוביל למספר אקספוננציאלי של מצבים, ולצרוך זיכרון משמעותי.

אוטומטים סופיים אי-דטרמיניסטיים (NFA): נתיב האפשרויות

כעת, דמיינו סוג אחר של מכונה. כשהיא קוראת תו, ייתכנו לה מספר מצבים הבאים אפשריים. זה כאילו המכונה יכולה לשכפל את עצמה כדי לחקור את כל הנתיבים בו זמנית. מנוע NFA מדמה תהליך זה, בדרך כלל על ידי ניסיון נתיב אחד בכל פעם וביצוע backtracking אם הוא נכשל. זהו NFA.

• כיצד זה עובד: מנוע NFA עובר דרך תבנית ה-regex, ועבור כל אסימון בתבנית, הוא מנסה להתאימו מול המיקום הנוכחי במחרוזת. אם אסימון מאפשר מספר אפשרויות (כמו האלטלרנציה `|` או קוונטיפייר `*`), המנוע עושה בחירה ושומר את האפשרויות האחרות למאוחר יותר. אם הנתיב הנבחר נכשל בהפקת התאמה מלאה, המנוע חוזר אחורה (backtracks) לנקודת הבחירה האחרונה ומנסה את האלטרנטיבה הבאה.
• חוזקות:
  • תכונות עוצמתיות: מודל זה תומך בערכת תכונות עשירה, כולל קבוצות לכידה, backreferences, lookaheads, lookbehinds, וכן quantifiers חמדניים (greedy) ועצלים (lazy).
  • אקספרסיביות: מנועי NFA יכולים להתמודד עם מגוון רחב יותר של תבניות מורכבות.
• חולשות:
  • שונות בביצועים: במקרה הטוב, מנועי NFA מהירים. במקרה הגרוע, מנגנון ה-backtracking יכול להוביל למורכבות זמן אקספוננציאלית, O(2^n), תופעה הידועה בשם "backtracking קטסטרופלי".

לב ליבו של מודול ה-`re` של פייתון: מנוע ה-NFA עם Backtracking

מנוע ה-regex של פייתון הוא דוגמה קלאסית ל-NFA עם backtracking. הבנת מנגנון זה היא הרעיון החשוב ביותר לכתיבת ביטויים רגולריים יעילים בפייתון. בואו נשתמש באנלוגיה: דמיינו שאתם במבוך ויש לכם סט כיוונים (התבנית). אתם עוקבים אחר נתיב אחד. אם אתם מגיעים למבוי סתום, אתם חוזרים על עקבותיכם לצומת האחרון שבו הייתה לכם בחירה ומנסים נתיב אחר. תהליך "חזור ונסה שוב" זה הוא backtracking.

דוגמה ל-Backtracking צעד אחר צעד

בואו נראה כיצד המנוע מטפל בתבנית פשוטה לכאורה. דוגמה זו מדגימה את מושג הליבה של התאמה חמדנית (greedy matching) ו-backtracking.

• תבנית: a.*b
• מחרוזת: axbyc_bzd

המטרה היא למצוא תת-מחרוזת שמתחילה ב-'a', מסתיימת ב-'b', ויש לה כל דבר ביניהם.

1. המנוע מתחיל בתו הראשון של המחרוזת. החלק הראשון של התבנית הוא a. הוא מתאים ל-'a' בתחילת המחרוזת. מיקום המנוע נמצא כעת לאחר 'a'.
2. הבא בתור הוא .*. הקוונטיפייר * הוא חמדן (greedy) כברירת מחדל. זוהי נקודה קריטית. קוונטיפייר חמדן יתאים כמה שיותר תווים. לכן, .* צורך את כל יתרת המחרוזת: `xbyc_bzd`.
3. המנוע הגיע כעת לסוף החלק .* של התבנית ומנסה להתאים את האסימון הבא: b. עם זאת, הוא כבר נמצא בסוף המחרוזת. לא נותרו תווים להתאמה. ההתאמה נכשלת במיקום זה.
4. BACKTRACK! המנוע חייב לשקול מחדש את בחירתו האחרונה. הבחירה העיקרית האחרונה הייתה כמה תווים הקוונטיפייר החמדן .* צריך לצרוך. הוא היה חמדן מדי. לכן, הוא מבצע backtracking: .* מחזיר תו אחד.
   • המחרוזת שנצרכה על ידי .* היא כעת `xbyc_bz`.
   • התו שהוחזר הוא `d`.
   • המנוע מנסה להתאים את b מול `d`. זה נכשל.
5. BACKTRACK שוב! ה-.* מחזיר תו נוסף.
   • המחרוזת שנצרכה על ידי .* היא כעת `xbyc_b`.
   • התו שהוחזר הוא `z`.
   • המנוע מנסה להתאים את b מול `z`. זה נכשל.
6. BACKTRACK שוב! ה-.* מחזיר תו נוסף.
   • המחרוזת שנצרכה על ידי .* היא כעת `xbyc_`.
   • התו שהוחזר הוא `b`.
   • המנוע מנסה להתאים את b מול `b`. הצלחה!
7. התבנית כולה a.*b הותאמה כעת. ההתאמה הסופית היא axbyc_b.

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

הסכנה של Backtracking: Catastrophic Backtracking

Catastrophic backtracking הוא תרחיש ספציפי, במקרה הגרוע ביותר, שבו מספר התמורות שהמנוע חייב לנסות גדל באופן אקספוננציאלי. זה יכול לגרום לתוכנית להיתקע, לצרוך 100% מליבת CPU למשך שניות, דקות, או אפילו יותר, וליצור למעשה פגיעות Regular Expression Denial of Service (ReDoS).

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

שקלו את הדוגמה הפתולוגית הקלאסית:

• תבנית: (a+)+z
• מחרוזת: aaaaaaaaaaaaaaaaaaaaaaaaaz (25 'a's ו-'z' אחד)

זה יתאים במהירות רבה. ה-`(a+)+` החיצוני יתאים את כל ה-'a's בבת אחת, ואז `z` יתאים ל-'z'.

אבל עכשיו שקלו מחרוזת זו:

• מחרוזת: aaaaaaaaaaaaaaaaaaaaaaaaab (25 'a's ו-'b' אחד)

הנה מדוע זה קטסטרופלי:

1. ה-a+ הפנימי יכול להתאים תו 'a' אחד או יותר.
2. הקוונטיפייר החיצוני + אומר שקבוצת (a+) יכולה לחזור על עצמה פעם אחת או יותר.
3. כדי להתאים את מחרוזת ה-25 'a's, למנוע יש דרכים רבות מאוד לחלק אותה. לדוגמה:
   • הקבוצה החיצונית מתאימה פעם אחת, כאשר ה-a+ הפנימי מתאים את כל 25 ה-'a's.
   • הקבוצה החיצונית מתאימה פעמיים, כאשר ה-a+ הפנימי מתאים 'a' אחד ואז 24 'a's.
   • או 2 'a's ואז 23 'a's.
   • או שהקבוצה החיצונית מתאימה 25 פעמים, כאשר ה-a+ הפנימי מתאים 'a' אחד בכל פעם.

המנוע ינסה תחילה את ההתאמה החמדנית ביותר: הקבוצה החיצונית מתאימה פעם אחת, וה-`a+` הפנימי צורך את כל 25 ה-'a's. ואז הוא מנסה להתאים את `z` מול `b`. הוא נכשל. אז הוא חוזר אחורה. הוא מנסה את החלוקה האפשרית הבאה של ה-'a's. ואת הבאה. ואת הבאה. מספר הדרכים לחלק מחרוזת של 'a's הוא אקספוננציאלי. המנוע נאלץ לנסות כל אחת ואחת לפני שהוא יכול להסיק שהמחרוזת אינה מתאימה. עם 25 'a's בלבד, זה יכול לקחת מיליוני צעדים.

כיצד לזהות ולמנוע Catastrophic Backtracking

המפתח לכתיבת regex יעיל הוא להנחות את המנוע ולהפחית את מספר צעדי ה-backtracking שהוא צריך לבצע.

1. הימנעו מקוונטיפיירים מקוננים עם תבניות חופפות
הגורם העיקרי ל-catastrophic backtracking הוא תבנית כמו (a*)*, (a+|b+)*, או (a+)+. בדקו היטב את התבניות שלכם למבנה זה. לעתים קרובות, ניתן לפשט אותו. לדוגמה, (a+)+ זהה פונקציונלית ל-a+ הבטוח הרבה יותר. התבנית (a|b)+ הרבה יותר בטוחה מ-(a+|b+)*.

2. הפכו קוונטיפיירים חמדניים לעצלים (לא-חמדניים)
כברירת מחדל, קוונטיפיירים (`*`, `+`, `{m,n}`) הם חמדניים. ניתן להפוך אותם לעצלים על ידי הוספת `?`. קוונטיפייר עצל מתאים את מספר התווים הקטן ביותר האפשרי, ומרחיב את ההתאמה שלו רק אם הדבר הכרחי כדי ששאר התבנית תצליח.

• חמדני: <h1>.*</h1> על המחרוזת "<h1>Title 1</h1> <h1>Title 2</h1>" יתאים את כל המחרוזת מה-<h1> הראשון ועד ה-</h1> האחרון.
• עצל: <h1>.*?</h1> על אותה מחרוזת יתאים תחילה את "<h1>Title 1</h1>". זו לעתים קרובות ההתנהגות הרצויה ויכולה להפחית באופן משמעותי את ה-backtracking.

3. השתמשו בקוונטיפיירים פוסיסיביים (Possessive Quantifiers) ובקבוצות אטומיות (Atomic Groups) (כאשר אפשר)
חלק ממנועי ה-regex המתקדמים מציעים תכונות האוסרות במפורש backtracking. בעוד שמודול ה-`re` הסטנדרטי של פייתון אינו תומך בהם, מודול ה-`regex` החיצוני המצוין כן תומך בהם, והוא כלי משתלם להתאמת תבניות מורכבות.

• קוונטיפיירים פוסיסיביים (`*+`, `++`, `?+`): אלה דומים לקוונטיפיירים חמדניים, אך ברגע שהם מתאימים, הם לעולם אינם מחזירים תווים. למנוע אסור לבצע backtracking לתוכם. התבנית (a++)+z תיכשל כמעט באופן מיידי על המחרוזת הבעייתית שלנו מכיוון ש-`a++` יצרוך את כל ה-'a's ואז יסרב לבצע backtracking, מה שיגרום לכשל מיידי של ההתאמה כולה.
• קבוצות אטומיות `(?>...)`:** קבוצה אטומית היא קבוצה שאינה לוכדת, וברגע שיוצאים ממנה, היא משליכה את כל עמדות ה-backtracking שבתוכה. המנוע אינו יכול לבצע backtracking לתוך הקבוצה כדי לנסות תמורות שונות. `(?>a+)z` מתנהג באופן דומה ל-`a++z`.

import re

# בואו ננתח את התבנית 'a(b|c)+d'
re.compile('a(b|c)+d', re.DEBUG)

LITERAL 97          # התאם את התו 'a'
MAX_REPEAT 1 65535  # התחל קוונטיפייר: התאם את הקבוצה הבאה 1 עד הרבה פעמים
  SUBPATTERN 1 0 0    # התחל קבוצת לכידה 1
    BRANCH            # התחל אלטרנציה (תו ה-'|')
      LITERAL 98      # בענף הראשון, התאם 'b'
    OR
      LITERAL 99      # בענף השני, התאם 'c'
    MARK 1            # סיים קבוצת לכידה 1
LITERAL 100         # התאם את התו 'd'
SUCCESS             # התבנית כולה הותאמה בהצלחה