ביטויים רגולריים בפייתון
מאמר זה מסביר ביטויים רגולריים בפייתון.
נדון בנושאים רבים, משימוש בסיסי במודול re ועד התאמת תבניות מורכבות של ביטויים רגולריים.
YouTube Video
ביטויים רגולריים בפייתון
המודול re משמש לחיפוש ולמניפולציה על מחרוזות תוך שימוש בביטויים רגולריים.
מהו המודול re?
המודול re כלול בספרייה הסטנדרטית של פייתון ומספק יכולות לעיבוד מחרוזות באמצעות ביטויים רגולריים. ביטויים רגולריים משמשים לחיפוש, חילוץ או החלפה של תבניות מחרוזת מסוימות בצורה יעילה.
תבניות בסיסיות של ביטויים רגולריים
ביטויים רגולריים מגדירים תבניות באמצעות סמלים מיוחדים. להלן כמה תבניות בסיסיות.
.: כל תו יחיד^: תחילת מחרוזת$: סוף מחרוזת\d: כל ספרה (0-9)\w: כל תו מילה (a-z, A-Z, 0-9, _)\s: כל תו רווח*: אפס או יותר חזרות+: אחד או יותר חזרות[]: מחלקת תווים (לדוגמה,[a-z]תואם לאותיות קטנות באנגלית)
1import re
2
3pattern = r"\d{3}-\d{4}"
4text = "My postal code is 123-4567."
5result = re.search(pattern, text)
6if result:
7 print(result.group()) # Output: 123-4567
8
9# Define a pattern using basic regular expression symbols
10pattern = r"^\w+\s\d+\s[a-zA-Z]+$"
11
12# Example text to test the pattern
13text = "Room 23 Tokyo"
14
15# Check if the pattern matches the text
16result = re.match(pattern, text)
17if result:
18 print("Matched:", result.group())
19else:
20 print("No match")- הקוד הזה קודם בודק האם המחרוזת תואמת לתבנית של מיקוד. לאחר מכן הוא בודק האם כל המחרוזת (מהתחלה ועד הסוף) תואמת לתבנית המורכבת ממילה, תו רווח לבן, ספרות, תו רווח לבן ומילה באנגלית. זה עוזר לך להבין כיצד ניתן לשלב את המרכיבים הבסיסיים של ביטויים רגולריים.
כיצד להשתמש בפונקציות התאמה
re.match()
re.match() בודק אם תחילת המחרוזת מתאימה לתבנית שצוינה.
1import re
2
3pattern = r"\w+"
4text = "Python is powerful"
5match = re.match(pattern, text)
6if match:
7 print(match.group()) # Output: Python- הקוד הזה בודק אם המחרוזת מתחילה בתו מילה (אלפאנומרי או קו תחתון). המילה הראשונה 'Python' תואמת לתבנית ומודפסת.
re.search()
re.search() סורק את המחרוזת כולה ומחזיר את ההתאמה הראשונה.
1import re
2
3pattern = r"powerful"
4text = "Python is powerful and versatile"
5search = re.search(pattern, text)
6if search:
7 print(search.group()) # Output: powerful- הקוד הזה מחפש בכל המחרוזת את המילה 'powerful' ומחזיר את ההתאמה הראשונה. כתוצאה מכך,
re.search()מחזיר את המחרוזת שהתאימה 'powerful'.
re.findall()
re.findall() מחזיר את כל ההתאמות של התבנית כרשימה.
1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.findall(pattern, text)
6print(matches) # Output: ['Python', 'strong']- הקוד הזה מוצא את כל המילים שאורכן בדיוק שישה תווים ומחזיר אותן כרשימה. 'Python' במחרוזת עומדת בתנאי, והרשימה
['Python']מוחזרת.
re.finditer()
re.finditer() מחזיר את כל ההתאמות כאיטרטור, המאפשר לך לקבל מידע מפורט על כל התאמה.
1import re
2
3pattern = r"\b\w{6}\b"
4text = "Python is powerful and versatile"
5matches = re.finditer(pattern, text)
6for match in matches:
7 print(match.group()) # Output: Python- הקוד הזה מחפש ברצף את כל המילים בעלות שישה תווים ומעבד כל התאמה באמצעות איטרטור. 'Python' תואמת כאן לתבנית ומוחזרת.
החלפה ופיצול
re.sub()
re.sub() מחליף חלקים מהמחרוזת שתואמים את הביטוי הרגולרי במחרוזת אחרת.
1import re
2
3pattern = r"\d+"
4text = "There are 100 apples"
5new_text = re.sub(pattern, "many", text)
6print(new_text) # Output: There are many apples- הקוד הזה מחליף את כל הספרות במחרוזת ב-'many'.
re.split()
re.split() מפצל את המחרוזת באזורים התואמים את הביטוי הרגולרי.
1import re
2
3pattern = r"\s+"
4text = "Python is powerful"
5parts = re.split(pattern, text)
6print(parts) # Output: ['Python', 'is', 'powerful']- הקוד הזה מפצל את המחרוזת על-פי תו רווח לבן אחד או יותר. כתוצאה מכך, המחרוזת מפוצלת למילים ומתקבלת הרשימה
['Python', 'is', 'powerful'].
קבוצות ולכידות
שימוש בקבוצות ביטוי רגולרי מקל על שליפת תת-מחרוזות תואמות. סגירה בתוך סוגריים () לוכדת אותה כקבוצה.
1import re
2
3pattern = r"(\d{3})-(\d{4})"
4text = "My postal code is 123-4567."
5match = re.search(pattern, text)
6if match:
7 print(match.group(1)) # Output: 123
8 print(match.group(2)) # Output: 4567- הקוד הזה מחלץ את המספרים בני 3 ספרות ו-4 ספרות כקבוצות נפרדות ממיקוד בצורת '123-4567'.
group(1)מחזירה את שלוש הספרות הראשונות '123', ו-group(2)מחזירה את ארבע הספרות האחרונות '4567'.
קבוצות בעלות שם
שימוש בקבוצות בעלות שם מאפשר לאחזר ערכים לפי שמות משמעותיים במקום להסתמך על אינדקסים. להלן דוגמה קונקרטית שמחלצת את התאריך והרמה מיומן רישום.
1import re
2
3log = "2025-10-25 14:00:01 [ERROR] Something failed"
4
5pattern = r"(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) \[(?P<level>[A-Z]+)\] (?P<msg>.*)"
6m = re.search(pattern, log)
7if m:
8 print(m.group("date"), m.group("time"), m.group("level"))
9 print("message:", m.group("msg"))- הקוד הזה משתמש בקבוצות בעלות שם כדי לחלץ את התאריך, הזמן, הרמה וההודעה ממחרוזת לוג. הוא מאחזר את הערכים באמצעות שמות משמעותיים ולא באמצעות אינדקסים.
שימוש באפשרויות דגל
למודול re יש מספר אפשרויות דגל לשליטה בהתנהגות החיפוש.
re.IGNORECASE(re.I): אפשרות דגל שהופכת את ההתאמה לבלתי רגישה לאותיות רישיות או קטנות.re.MULTILINE(re.M): אפשרות דגל שמאפשרת התאמה לאורך שורות מרובות.re.DOTALL(re.S): אפשרות דגל שבה הנקודה.תואמת גם תווי שורה חדשה.
1import re
2
3pattern = r"python"
4text = "Python is powerful"
5match = re.search(pattern, text, re.IGNORECASE)
6if match:
7 print(match.group()) # Output: Python- הקוד הזה מחפש את המילה 'python' ללא תלות ברישיות. באמצעות הדגל
re.IGNORECASEהוא יתאים גם את 'Python'.
יתרונות של אובייקטים של ביטויים רגולריים (re.compile)
קומפילציה של תבנית בעזרת re.compile הופכת שימוש חוזר ליעיל יותר ומשפרת את הקריאות. כאן ניתן גם להגדיר דגלים.
הדוגמה הבאה מחפשת שוב ושוב התאמות על פני שורות מרובות באמצעות תבנית מקומפלת. אם משתמשים באותה תבנית לעיתים קרובות, קומפילציה באמצעות re.compile משפרת ביצועים.
1import re
2
3pattern = re.compile(r"User: (\w+), ID: (\d+)")
4text = "User: alice, ID: 1\nUser: bob, ID: 2"
5
6for m in pattern.finditer(text):
7 print(m.groups())- הקוד הזה משתמש בביטוי רגולרי מקומפל כדי לחלץ שמות משתמש ומזהים משורות מרובות.
re.compileמשפר יעילות בעת שימוש חוזר באותה תבנית וגם הופך את הקוד לקריא יותר.
יישומים
לדוגמה, שקול סקריפט שמחלץ את כל כתובות האימייל מקובץ טקסט.
1import re
2
3pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
4text = "Contact us at info@example.com or support@service.com."
5emails = re.findall(pattern, text)
6print(emails) # Output: ['info@example.com', 'support@service.com']- הקוד הזה מוצא את כל כתובות הדוא"ל במחרוזת ומחלץ אותן כרשימה.
סיום
המודול re הוא כלי חזק למניפולציה על מחרוזות בפייתון. כאן כיסינו טווח רחב משימוש בסיסי ועד ביטויים רגולריים מתקדמים תוך שימוש בקבוצות ובאפשרויות דגל. הביטויים הרגולריים של פייתון הם חזקים מאוד וכלי שאין לו תחליף לעיבוד טקסטים.
תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.