פרק קודם:

מה נלמד

• מודול datetime
• date object
• datetime object
• timezones object
• tzinfo object

מודול datetime

קיים בפייתון המודול time.
אז למה לנו עוד מודול?

המודול datetime היא הרחבה ואפשר לומר אפילו שיפור למודול time.

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

הלוח הפופולרי הוא כמובן הלוח הגרגוריאני ואלו התאריכים הבסיסיים שאנחנו משתמשים בהם.

מודע ונאיבי

המודול יוצר השוואה בין 2 סוגים של מבנים.

• זמן מודע
• זמן נאיבי

זמן מודע הוא מבנה שיש לו ידע על אזור הזמן והקלנדר שלו.
למשל:
12:00 01/01/2025 +gmt 2
בפיסת המידע הזו יש 3 פרטי מידע:

• זמן
• תאריך
• אזור זמן

ותכלס מאזור הזמן אפשר גם להסיק את האזור הגאוגרפי.

זמן נאיבי הוא זמן שאיננו יודע מה אזור הזמן שלו והקלנדר שלו למשל:
17:00
01/01/2025

מהי החשיבות של מודע ונאיבי?

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

האם היום הוא יום עבודה?

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

• איזה יום היום
• לפי איזה קלנדר אנחנו מציגים את היום
• אילו ימים מוגדרים כימי עבודה לפי הקלנדר
• אילו ימים מוגדרים כימי עבודה על פי החוק המקומי
• האם היום יום שבתון?
• האם היום יום אבל?
• האם היום יום חג?
• האם היום חופש מאורגן של החברה?

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

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

אובייקט time

יחידת הבסיס במודול, האובייקט מייצג רק את הזמן.
הוא מכיל תכונות כמו hour, minute וכדו’…
כמו באובייקט time.time האובייקט datetime.time מכיל tzinfo.
ולכן הוא יכול להיות אובייקט מודע.

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

הרזולוציה של אובייקט time הוא milliseconds.
רזולוציה מגדירה את יחידת המידה הקטנה ביותר שניתן לחשב.

1
2

import datetime
d = datetime.time(12,0,15) # 12:00.15

בברירת מחדל כל הערכים אפסיים.

1
2
3
4
5

print(t.hour)         # 12
print(t.minute)       # 0
print(t.second)       # 15
print(t.microsecond)  # 0
print(t.tzinfo)       # None

לא ניתן לשנות ערכים:

1
2
3
4
5
6

>>> d.hour = 15
Traceback (most recent call last):
  File "<python-input-6>", line 1, in <module>
    d.hour = 15
    ^^^^^^
AttributeError: attribute 'hour' of 'datetime.time' objects is not writable

ניתן לפרמט את האובייקט למחרוזת:

1
2

d = datetime.time(12,0,15) # 12:00.15
d.strftime("%H:%M:%S")  # '12:00:15

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

1
2
3
4
5

d1 = datetime.time(12,0,15) # 12:00.15
d2 = datetime.time(14,0,00) # 12:00.15

d2 > d1 # True
d2 + d1 # Error

Fold

מאפיין מיוחד - יכול להכיל 0 או 1 וזה אומר האם האובייקט זמן הזה הוא חזרה על אותו הזמן.
מתי חזרה חשובה לנו?
כשאנחנו מזיזים את השעון אחורה.

זו תכונה חשובה לאובייקט זמן מודע.

שאלה
מה יוחזר מתוצאת הבדיקה הזו?
datetime.time(1,15,0, fold=1) > datetime.time(1,15,0)

תרגילים

1. כתבו פונקצייה שלא מקבלת פרמטרים ומחזירה בוליאני אם השעה היא שעת ארוחת צהריים.
   זכרו שניתן להשתמש במודול time.time כדי לקבל את השעה הנוכחית.
2. כתבו פונקציה המקבלת אובייקט זמן כפרמטר ומחזירה את השעה שעה אחורה.
   יש לשים לב שאם השעה היא 00:00 בלילה ומחזירים שעה אחורה אז זה יחזיר ל23:00.

תשובות

1
2
3
4
5

import time

def is_lunchtime():
    current_hour = time.localtime().tm_hour
    return 11 <= current_hour < 13

1
2
3
4
5

from datetime import time

def one_hour_back(t):
    hour_back = (t.hour - 1) % 24  # דואג שלא נרד מתחת ל־0
    return time(hour=hour_back, minute=t.minute, second=t.second, microsecond=t.microsecond)

אובייקט date

1
2
3
4
5

import datetime

d = datetime.date.today()

d2 = datetime.date(2025,1,16) # 16.01.2025

האובייקט מייצג יום בודד בלוח שנה.
יש לו שנה, חודש ויום.

למחלקה יש מתודות שאפשר להשתמש בהן מחוץ לאובייקט, למשל המתודה today נותנת לכם את התאריך של היום.

בתאריכים יש קונספט שנקרא ordinal שהוא דומה לקונספט של epoch.
לעומת epoch שמתחיל ב-1970, האורדינל מתחיל מתחילת הספירה המודרנית.

ניתן לבנות אובייקט כזה גם מתאריך ספציפי:

1
2
3

import datetime

d = datetime.date(2020,1,1)

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

מאפיינים פופולריים של האובייקט:

date.today מחזיר את היום.
date.fromisoformat - פורמט מאוד פופולרי, יותר אובייקט מהפורמט YYYY-MM-DD.
date.fromordinal – ממיר מספר ימים מתחילת הספירה לתאריך.

1
2
3
4
5
6
7
8

## פרמוט תאריך למחרוזת

הפורמט הבסיסי הוא בעזרת ``isoformat`` - 

```py
date(2025,1,1).isoformat() # 2025-01-01

ניתן לפרמט לבד גם בעזרת strftime:
ידעתם? זה קיצור ל- string format time.

כדי לשנות חזרה נוכל להשתמש ב- datetime.strptime(str, format).

למדנו כבר איך לפרמט אך שוב אחזור על טבלת המידע:

תרגילים

1. קבלו יום בין 1 ל 366 והמירו אותו לתאריך והציגו את התאריך בפורמט ISO - שימו לב שהשנה צריכה להיות השנה הנוכחית.
2. קבלו מחרוזת בפורמט ISO וכתבו למשתמש אם התאריך שהוזן הוא היום האחרון בחודש.

1
2
3
4
5
6
7
8

from datetime import date

def day_of_year_to_date(day):
    t = datetime.strptime(f"{day}", "%j")
    newD = date(date.today().year, t.month, t.day)
    return newD.isoformat()

print(day_of_year_to_date(150))

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

from datetime import date, timedelta

def is_last_day_of_month(date_str):
    d = date.fromisoformat(date_str)
    next_day = d + timedelta(days=1)
    return next_day.day == 1

user_date = "2024-02-29"
if is_last_day_of_month(user_date):
    print("Last day of month")
else:
    print("Not last day of month")

חישוב תאריכים - אובייקט timedelta

כמה ימים היינו בחופשה?
המפתח בוב החליט לא לפתוח לוח שנה פיזי ולחשב את זה בעזרת פייתון.
בוב פתח קובץ והתחיל לקדקד חישובים,
אבל אוי! בוב לא למד timedelta, עזרו לבוב למצוא את התאריך הנכון:

מהו החישוב הנכון? totalDays או totalDays2?

1
2
3
4
5
6
7

import datetime

startVacation = datetime.date(2020,7,1)
endVacation = datetime.date(2020, 9, 1)

totalDays = endVacation - startVacation
totalDays2 = startVacation - endVacation

1
2

totalDays = (endVacation - startVacation).days
totalDays2 = abs((startVacation - endVacation).days)

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

תרגילים

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

1
2
3
4
5
6
7
8

from datetime import date

today = date.today()
next_year = today.year + 1
new_year_date = date(next_year, 1, 1)

days_left = (new_year_date - today).days
print(f"There are {days_left} days until the new year 🎉")

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

from datetime import date

month = int(input("Enter the deadline month (1-12): "))
day = int(input("Enter the deadline day (1-31): "))

today = date.today()
year = today.year

try:
    deadline = date(year, month, day)
    if deadline < today:
        deadline = date(year + 1, month, day)
except ValueError:
    print("Invalid date entered!")
    exit()

delta = deadline - today

months = delta.days // 30
days = delta.days % 30

print(f"The deadline is on {deadline.isoformat()}.")
print(f"{months} months and {days} days left until the deadline 📝")

אובייקט datetime

כעת הכל מתכנס ליחידה אחת - גם תאריך וגם שעה.

1
2
3
4

from datetime import datetime

d = datetime(2025,1,1,12,0,15,500)
print(d)

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

חישוב שנים וחודשים

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

מה שאפשר לעשות זה להשתמש ב-python-dateutils, ספרייה חיצונית.

אובייקטים tzinfo & timezone

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

מה שאנחנו צריכים זה - datetime.timezone.
זוהי המחלקה של פייתון שיורשת את tzinfo.

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

1
2
3
4
5
6
7
8
9

from datetime import timezone, timedelta, datetime

tz = timezone(timedelta(hours=2), name="GMT+2")
dt = datetime(2025, 1, 1, 15, 0, tzinfo=tz)
print(dt)

utc = timezone.utc
now_utc = datetime.now(utc)
print(now_utc)

תרגילים

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

החבילה נשלחה ביום 31 באוגוסט 2025 בשעה 14:00 לפי שעון ישראל (UTC+3).
זמן הטיסה של החבילה הוא 11 שעות ו־45 דקות בדיוק.

חשב את זמן ההגעה לטוקיו לפי שעון מקומי (UTC+9)

הדפס את שעת היציאה וההגעה של החבילה בפורמט יפה
לדוגמה: Departing at 2025-08-31 14:00+03:00 | Arriving at 2025-09-01 03:45+09:00

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

from datetime import datetime, timedelta, timezone
import random

print("👨‍💼 US employee:")
us_min_hour = int(input("Enter earliest US hour (0–23): "))
us_max_hour = int(input("Enter latest US hour (0–23): "))

print("👩‍💼 China employee:")
cz_min_hour = int(input("Enter earliest China hour (0–23): "))
cz_max_hour = int(input("Enter latest China hour (0–23): "))

if us_min_hour >= us_max_hour or cz_min_hour >= cz_max_hour:
    print("❌ Invalid input: earliest must be before latest.")
    exit()

meeting_duration = timedelta(hours=1)

us_tz = timezone(timedelta(hours=-5))  # New York
china_tz = timezone(timedelta(hours=8))  # Beijing

today = datetime(2025, 8, 31)

us_start_utc = datetime(
    today.year, today.month, today.day, us_min_hour, tzinfo=us_tz
).astimezone(timezone.utc)
us_end_utc = datetime(
    today.year, today.month, today.day, us_max_hour, tzinfo=us_tz
).astimezone(timezone.utc)

china_start_utc = datetime(
    today.year, today.month, today.day, cz_min_hour, tzinfo=china_tz
).astimezone(timezone.utc)
china_end_utc = datetime(
    today.year, today.month, today.day, cz_max_hour, tzinfo=china_tz
).astimezone(timezone.utc)

overlap_start = max(us_start_utc, china_start_utc)
overlap_end = min(us_end_utc, china_end_utc)

available_minutes = int(
    (overlap_end - overlap_start - meeting_duration).total_seconds() / 60
)

if available_minutes >= 0:
    random_offset_minutes = random.randint(0, available_minutes)
    meeting_start_utc = overlap_start + timedelta(minutes=random_offset_minutes)
    meeting_end_utc = meeting_start_utc + meeting_duration

    meeting_us = meeting_start_utc.astimezone(us_tz)
    meeting_china = meeting_start_utc.astimezone(china_tz)

    print("\n✅ Randomly Selected Meeting Time:")
    print(f"🇺🇸 US local time:    {meeting_us.strftime('%Y-%m-%d %H:%M')} 🕰️")
    print(f"🇨🇳 China local time: {meeting_china.strftime('%Y-%m-%d %H:%M')} 🕰️")
    print(f"🕓 Duration: {meeting_duration}")
else:
    print("\n❌ No overlap found for a full 1-hour meeting.")

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

from datetime import datetime, timedelta, timezone

israel_tz = timezone(timedelta(hours=3))
tokyo_tz = timezone(timedelta(hours=9))

departure_time = datetime(2025, 8, 31, 14, 0, tzinfo=israel_tz)

flight_duration = timedelta(hours=11, minutes=45)

departure_utc = departure_time.astimezone(timezone.utc)
arrival_utc = departure_utc + flight_duration

arrival_tokyo = arrival_utc.astimezone(tokyo_tz)

print(f"📦 Departing at {departure_time.isoformat()} | Arriving at {arrival_tokyo.isoformat()}")

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

טיפ:

רוב הזמן נרצה לשמור זמנים ב-UTC כי קל לנו להמיר את התאריך לאזורי זמן שונים.

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