פרק קודם:

מה נלמד

• מה זה רגקס - Regex
• איך עובדים עם רגקס
• כתיבת קוד בעזרת רגקס
• טיפים לכתיבת רגקס טוב

הקדמה

טקסט קיים בכל מקום - אפילו מילים אלו זה טקסט שאתם קוראים!
בתוכנה אנו כותבים וקוראים תוכן טקסטואלי - אלו מילים קריאות לשפה האנושית ולא 0 או 1.

בפרק “שפה בינארית וקבצים בינאריים” אני מסביר על מידע שאינו טקסטואלי.

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

• כתובת מייל
  “name@domain.extension“
• כתובת IP:
  192.168.1.1
• סיסמא חזקה:
  f&s@lam1MM

אם נפרט את תוכן התבנית, נוכל לחלק את התבניות בצורה הזו:

Regular Expressions - Regex - רגקס

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

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

הרצה ובדיקה של ביטוי רגקס

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

https://regex101.com/

למשל כאן אני בודק את התבנית abcdef.

קודם כל נכיר את חוקי הרגקס וכיצד כותבים אותו, לאחר מכן נראה איך נכתוב את הקוד בפייתון!

שימו ❤:

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

חוקיי רגקס

כל תו מאמת את עצמו

כל תו ניתן לאמת כאשר התו הזה מופיע.
הרגקס ‘abc’ יימצא כל ‘abc’.

הוספת סלאש כדי להגדיר תווים מיוחדים

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

1

\.

זה אומר “תרתי משמע אני רוצה נקודה”.
לעומת

1

.

שאומר כל תו (מיד נסביר על תווים מיוחדים).

זה נכון לכל התווים המיוחדים המוגדרים פה כמו סוגריים ותווים כמו: ^, ?, $ וכדו’…

סוג תווים שונים

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

הערה חשובה

התו הזה הוא מיוחד כי הוא מוצא תווים שלא רואים אותם, כמו רווחים.
יש תו מאוד חשוב לפייתון שהוא הטאב- הוא מוגדר בצורה שונה לפעמים,
הטאב מוסיף רווח גדול והוא מוגדר כ- “t\“.
או “סלאש טי”.
ככה עושים אותו:

כמו טאב ורווח יש גם תווים מיוחדים לשורה חדשה שהוא נכתב “n\“.

בדוגמא הזו אני מוצא כל מה שיש לו שורה חדשה בין a ל-b.

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

1
2

regexString = '\\t'
regexStringTwo = r'\t'

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

תרגיל

הריצו את הרגקסים האלו באתר Regex101.
תנסו למצוא דוגמאות שיתאימו עבור הרגקסים הבאים:

1.

1

\w\s\d

2.

1

file_\d\d\d

3.

1

\W\W\W

1
2
3

a 1
b 5
_ 1

1
2

file_123
file_662

1
2
3

   
***
!!!

בדיקת כמות של תווים

ניתן לבדוק כמות תווים ע”י התבניות הבאות:

קבוצות וטווחים

Wildcard

זהו מונח שבדרך כלל מתייחס לחיפוש כל תו שהוא.
או בערת רגקס - נקודה כוכבית - .*.
נקודה כוכבית נותנת לנו לחפש כל דבר.

עוגנים

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

תרגיל

תכתבו רגקסים לחיפוש טקסט:

1. מציאת שם שאורכו 4 תווים באותיות אנגליות קטנות או גדולות

2. מציאת תוויות של מוצרים אשר מוגדרים כ9 מספרים בין 1 ל 8.

3. מצאו תאריך בפורמט הבא:
   שנה-חודש-יום.
   למשל:

1

25.2.2021

4. כתבו רגקס לחיפוש הטקסט הבא:

1

[933]

מורכב משני סוגריים מרובעות עם 3 מספרים בפנים.
5. כתבו רגקס לחיפוש שני קבוצות:

1

AGFA 6641

הקבוצה הראשונה - אותיות אנגליות גדולות בלבד
ואז יש רווח
ואז 4 מספרים מ0 עד 9.

Answer

1.

1

[\w]{4}

2.

1

[1-8]{9}

3.

1	[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{4}

4.

1	\[[0-9]{3}\]

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

1

[0-9]{3}

שהוא מחפש בדיוק 3 מספרים בין 0 ל9.

5.

1	([A-Z]){4}\s{1}([0-9]{4})

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

שימו לב שהטקסט מכיל יותר אך הוא מוצא רק את ה-4 תווים הראשונים.

מימוש פייתון - אימות קלט

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

שימו לב ששמתי דולר במקום הסימן @ - והאתר הביא לי סימן כתום שאומר ששמתי מידע לא נכון.
ברגע שאני שם סימן נכון זה כבר לא מופיע:

מימוש תמים לאימות אימייל

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def ValidateEmail(email):
  atSignSplit = email.split('@')
  if len(atSignSplit) < 2:
    return False
  site = atSignSplit[1]
  dotSplit = site.split('.')
  if len(dotSplit) < 2:
    return False
  else:
    return True

emails = [
'iluga@simplycode.co.il',
'iluga$simplycode.co.il'
]
for email in emails:
    isValid = ValidateEmail(email)
    if isValid:
        print(f"Email {email} is valid")
    else:
        print(f"Email {email} is not valid")

המימוש התמים בודק אם אנחנו יכולים קודם כל לפצל בעזרת התו-@.
לאחר מכן אנחנו בדקנו אם ניתן את הצד הימני לפצל עם נקודה - כי אנחנו מחפשים את התו נקודה.
ואם יש אזי יש לנו אימייל מאומת.

הקוד לא ייעבוד כמו שצריך בחלק מהמקרים, מה אם אשים אימייל כזה:

1

iluga@!@$!%^SDADSA.com.il.asasas.asdas

אז הוא ייכתוב:
Email iluga@!$!%^SDADSA.com.il.asasas.asdas is valid

מימוש חכם יותר בעזרת חוקי רגקס

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import re

def ValidateEmail(email):
  emailRegex = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
  if re.search(emailRegex, email):
    return True
  return False

emails = [
'iluga@simplycode.co.il',
'a@gmail.com',
'iluga$simplycode.co.il',
'iluga@simplycode . co.il'
]
for email in emails:
    isValid = ValidateEmail(email)
    if isValid:
        print(f"Email {email} is valid")
    else:
        print(f"Email {email} is not valid")

המודול שנשתמש בו בפייתון נקרא re, קיצור ל-RegularExpression.
המודול מאפשר לנו לחפש על מחרוזות בעזרת המתודות search ו-match.

בדוגמא למעלה קראנו לפונקציה בצורה הזו:
re.search(emailRegex, email)

• פרמטר 1 - התבנית של הרגקס
• פרמטר 2 - המחרוזות שעליה אנחנו מחפשים

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

1

emailRegex = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

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

1

a = 'a@gmail.com'

1

a = '22a: xzx Hello my name is a@gmail.com"

• הסוגריים המרובעות מאגדות חוקים ל”חוק אחד”.

• המקף ‘-‘ אומר שיש לנו התחלה וסוף,
  בביטוי כמו [a-z]+ אנו מורים לחפש אחת או יותר אותיות אנגליות קטנות בלבד!
  אותיות כמו c, g, k, u ייעברו את החוק כי הם בין האותיות שהגדרנו - a עד z.
  כדי לתפוס אותיות גדולות אנחנו צריכים להגדיר גם כן את החוק הזה לאותיות גדולות.
  [a-zA-Z]+ - ייתפוס גם אותיות גדולות.

שימו לב שביטוי כמו [az]+ יתפוס רק את a ו-z.

זה עובד גם על תווי מספר, הגדרנו שמחרוזות שמכילות גם 0 עד 9 גם ייעברו.
שימו לב שאין צורך בלהגדיר 10-99 וכאלו כי אנחנו מגדירים סוג תו שמופיע כמות פעמים.
אז למשל הרגקס:

1

[0-9]+

אומר התווים מ0 עד 9 אחד פעמים או יותר, אז כל המספרים האלו ייעברו:
0, 9, 99, 12012, 37412, 6312

• וסימנים כמו _ + . - בתוך הסוגריים המרובעות אומרים תווים רגילים, תרתי משמע התווים.

שימו לב שיש עוד שני איגודים כאלו - בורוד וצהוב.

1

a.

פונקציות חיפוש בפייתון

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

1

import re

findall

הפונקציה הזו מחזירה ברשימה את כל התוצאות:

1
2
3
4
5
6
7

import re

text = '12 11 66 aa 77'

results = re.findall('[0-9]+',text)

print(results)

split

הפונקציה מפצלת את המחרוזת ע”פ החיפוש,
למשל לעשות פיצול ע”י רווחים במשפט:

1
2
3
4
5
6
7

import re

text = 'Never put a sock in a toaster'

results = re.split('\s',text)

print(results)

search

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

ניגשים למשתנה בעזרת הנקודה
למשל:

1
2
3
4
5
6
7
8
9

import re

txt = '111 222 333'
match = re.search('([0-9]+)\s([0-9]+)\s([0-9]+)', txt)

print(match.groups())
print(match.group(0))
print(match.group(1))
print(match.group(2))

אנחנו יכולים לגשת לרשימת הקבוצות - זה חוזר אלינו כ-Tuple.
הקבוצה הראשונה היא כל המחרוזת שנמצאה כולל כל הקבוצות.
ואז הקבוצה הראשונה באינדקס הראשון - 1 זוהי הקבוצה הכי ראשונה, ואז 2 ואז 3.
תריצו את הקוד ותראו מה יוצא!

sub

הפונקציה מחליפה את כל הטקסט שהיא מצאה במחרוזת אחרת.

1
2
3
4
5
6
7
8
9

import re

txt = 'Hello _____, My congratulations on your new job _____, Regards, your cousin.'

replaceTo = 'Bob'

result = re.sub('\_{5}', replaceTo ,txt)

print(result)

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

Flags

ניתן להוסיף פרמטר נוסף לחלק מהפונקציות שנקרא “דגלים”.
את הדגלים ניתן להוסיף בעזרת האופרטור “ועוד” שכותבים אותו כקו ישר |.

יש לנו את השימוש המקוצר ולידו את השימוש הארוך (איך שנוח לכם להשתמש).

1
2
3
4

import re

txt = '111 222 333'
match = re.search('([0-9]+)\s([0-9]+)\s([0-9]+)', txt, re.IGNORECASE | re.MULTILINE)

תרגיל

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

1
2
3
4

25-02-2021 12:00:01.000 Info System.cs (25): Hello World
25-02-2021 12:00:01.000 Debug ImageTranslator.cs (58): Image Translator initialized
25-02-2021 12:00:01.001 Debug ImageSender.cs (90): Sender looking for device
25-02-2021 12:00:01.001 Error ImageSender.cs (94): Sender couldn't find device 

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

• עליכם למצוא מהם החלקים השונים של הלוג
• לכתוב רגקס שיתאים לכל החלקים שלו
• בונוס: תשמרו את השורות האלו לקובץ שנקרא “System.log” ואז תקראו ממנו שורה שורה.

2.
לדף אינטרנט ששומר תגובות של אנשים דרושה פונקציה שתנקה את הקלט של משתמש.
מכיוון שקלט של משתמש הוא לא בטוח - חייבים לוודא שהוא בטוח להצגה אחרת יהיו לנו בעיות אבטחה כגון XSS.
תקראו על זה בויקיפדיה

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

1
2

<div> My Attack</div>
<script src="https://someMaliciousSite.com/myscripts.js"></script>

אנחנו רוצים לתפוס את כל התגיות התחלה ותגיות הסיום ולהחליף אותם בטקסט ריק.

• איך נראית תגית התחלה וסיום?
• מהו הרגקס עבור זיהוי כל התגיות האלו?
  כרגע נניח שהתגיות עם תחילית וסיומת - ז”א אין תגיות שיש להם רק התחלה ללא תגית הסוף.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import re


def ParseLogLine(line):
    #                   1           2           3        4          5           6
    # Grouping:  '(25-02-2021) (12:00:01.000) (Info) (System.cs) \((25)\): (Hello World)'
    lineRegex = '([0-9\-]+) ([0-9\:\.]+) ([\w]+) ([\w\d\.]+) \(([\d]+)\): (.*)'
    match = re.search(lineRegex, line)
    PrintLogGroups(match.groups())

def PrintLogGroups(groups):
    numOfGroups = len(groups)
    if numOfGroups < 6:
        print("Didn't find proper log")
    else:
        date = groups[0]
        time = groups[1]
        level = groups[2]
        fileName = groups[3]
        lineNumber = groups[4]
        message = groups[5]
        print("--------------")
        print(f'Date : {date}')
        print(f'Time : {time}')
        print(f'Level : {level}')
        print(f'File : {fileName}')
        print(f'Line Number : {lineNumber}')
        print(f'Message : {message}')
        print("--------------")


with open('system.log') as file:
    while (line := file.readline()) != '':
        ParseLogLine(line)

1
2
3
4
5
6
7
8
9
10

if level == 'Error':
    print("--------------")
    print(f'Date : {date}')
    print(f'Time : {time}')
    print(f'Level : {level}')
    print(f'File : {fileName}')
    print(f'Line Number : {lineNumber}')
    print(f'Message : {message}')
    print("--------------")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import re


def SanitizeInput(userInput):
    regex = r'\<(.*)\s*.*\>.*\</\1\>\n?'
    return re.sub(regex, '', userInput, flags=re.IGNORECASE | re.MULTILINE)


userInput = '''
I give it 5 stars
<div>My Attack</div>
<script src="https://someMaliciousSite.com/myscripts.js"></script>
:>
'''

print(userInput)
sanitized = SanitizeInput(userInput)
print("After ")
print(sanitized)

1

\1

1

\2 \3 \4 \5 \6

1

<script> </script>

1

<script </scprit>

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

בפרק הבא נתחיל נושא מורכב שמהווה את מהות התכנות המודרני, תכנות מונחה עצמים!