פרק קודם:

מה נלמד

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

הקדמה

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

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

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

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

ננסה להבין את מהות התוכן ולבנות תבנית מסודרת:

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

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

• אותיות אנגליות קטנות וגדולות ומספרים וסימן נקודה.
• התו @
• אותיות אנגליות קטנות וגדולות ומספרים וסימן נקודה.

אותיות גדולות וקטנות נראות ככה:
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
עכשיו ננסה לקצר את זה ונאמר פשוט:
a-zA-Z.
איך נייצג מספרים?
012345679
או פשוט יותר:
0-9.

עכשיו אנחנו צריכים להוסיף סימן שיגיד לנו כמה פעמים התו יופיע.
אם רק נאמר 0-9 זה לא אומר לנו כמה פעמים זה אמור להופיע!
אז נניח שהתו * יגיד לנו 0 או יותר.
אז לייצג ביחד נוכל לומר:
a-ZA-Z0-9*

אבל פה מתחילה בעיה - אם נניח יש לי 2 תווים באנגלית ותו מספרי איך אני יודע מהי הכמות שתו יכול להופיע בו?
נפתור את זה בעזרת סוכם אשר אומר אחד מהתווים האלו.
ונשתמש בסוגריים מרובעות בשביל זה:
[a-zA-Z0-9]*

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

וע”י הגיון פשוט הגענו למשפט רגקס תקין!

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>

טיפים לרגקס

1 - השתמנו באתר Regex101

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

2 - השתמשו ב-AI כדי לייצר רגקסים מורכבים

1

Generate me regex that validates me hebrew letters where the third one is always a dot and the a group of "ישראל" may be contained in the sentence somewhere

1
2
3
4
5
6
7
8
9
10
11
12

Here’s a regex pattern that meets your requirements:

^[א-ת]{2}\.[א-ת]*ישראל[א-ת]*$
Explanation:

^[א-ת]{2}: The string starts with exactly two Hebrew letters.

.: The third character must be a dot (.).
[א-ת]ישראל[א-ת]$: After the dot, there can be any sequence of Hebrew letters, but the sequence "ישראל" must be present somewhere within that string.

This pattern ensures the third character is a dot, and the word "ישראל" is present somewhere in the string.

3 - השתמשו בסוגריים

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

4 - השתמשו בעוגנים

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

1

^I am.*$

הרגקס הנ”ל יציע לנו את כל השורות שמתחילות ב-I am.

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

למשל אנחנו רוצים להחליף את שם הפונקציה שלנו וה-IDE לא עוזר לנו כל כך.
ניתן לבצע את זה בעזרת חיפוש טקסטואלי עם רגקס- איך?
תוכנות כמו - notepad++ מאפשרים לנו להכניס קבוצות שמצאנו בתור הטקסט שיוחלף

הפונקציה שאנו רוצים להחליף אותה:

1

public void MyFunction(int a){}

אז נבנה רגקס:

1

public void MyFunction(\(int a\)\{\})

שימו לב ששמנו את התוכן שאחרי המילה בקבוצה - כעת ניתן להחליף בקלות את הכל מבלי סיכונים:

1

public void MyNewName$1

בNotepad++ זה ייגרום להחלפה מלאה של הפונקציה.

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

6 - אפשר גם לא לתפוס קבוצות

בעזרת (?:.*) נוכל לא לתפוס את הקבוצה.
למשל (?:[a-z]*).

7 - צפייה אחורה וקדימה

למשל אני רוצה לחפש את כל מה שיש לו תחילית של מספר ונקודה כדי שאוכל לחפש רשימות בתוך טקסט:

1
2
3

1. A
2. B
3. C

אני אוכל לכתוב רגקס כזה:

1

^(?<=[0-9]+\.).*$

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

הפוך ניתן להשתמש ב- (?=).

8 - הוספה של חיפוש עצלני

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

1

a.*?b

יימצא לנו את הטקסט הקצר בין a ל-b.

9 - מתן שמות לקבוצות

1

(?<name>...)

10 - אפשרו לשים הערות בתוך הרגקס עצמו

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

בפייתון נוכל להשתמש בו כך:

1
2
3
4
5
6
7
8
9
10
11
12

import re

pattern = re.compile(r'''
    \d{3}       # Match three digits (area code)
    \s*         # Match any whitespace (optional)
    -           # Match a hyphen
    \d{4}       # Match four digits (phone number)
    ''', re.VERBOSE)

match = pattern.search('123 - 4567')
print(match.group())  # Output: 123-4567

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

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