datetime ב-Python: תאריכים, שעות, timedelta ואזורי זמן

שני הטיפוסים המרכזיים: date ו-datetime

המודול datetime נותן ארבעה דברים שכדאי להכיר: date, time, datetime ו-timedelta. שלושת הראשונים הם בדיוק מה שהם נשמעים; הרביעי הוא פרק זמן.

from datetime import date, datetime, timedelta

today = date.today()
now = datetime.now()

print(today)
print(now)
print(type(today), type(now))

date מייצג יום (שנה, חודש, יום) בלי שעון. datetime הוא תאריך ועוד שעה. אם לא צריך את השעה, date היא הבחירה המסודרת יותר.

יצירת תאריכים ספציפיים

בונים ישירות:

from datetime import date, datetime

launch = date(2026, 1, 15)
meeting = datetime(2026, 1, 15, 14, 30)

print(launch)
print(meeting)

הארגומנטים הם year, month, day עבור date, ועד year, month, day, hour, minute, second, microsecond עבור datetime.

קריאת שדות

לכל date ו-datetime יש תכונות:

from datetime import datetime

now = datetime(2026, 4, 20, 9, 30, 15)

print(now.year, now.month, now.day)
print(now.hour, now.minute, now.second)
print(now.weekday())        # 0 = Monday, 6 = Sunday
print(now.isoweekday())     # 1 = Monday, 7 = Sunday
print(now.isoformat())

isoformat() היא החברה הכי טובה שלכם לפלט שמכונות קוראות: היא מייצרת משהו כמו "2026-04-20T09:30:15" שמערכות אחרות יכולות לפענח בלי עמימות.

עיצוב עם strftime

לפלט שבני אדם קוראים, .strftime(fmt) הופכת date או datetime למחרוזת מעוצבת:

from datetime import datetime

now = datetime(2026, 4, 20, 9, 30)

print(now.strftime("%Y-%m-%d"))          # 2026-04-20
print(now.strftime("%d %B %Y"))          # 20 April 2026
print(now.strftime("%I:%M %p"))          # 09:30 AM
print(now.strftime("%A, %d %b"))         # Monday, 20 Apr

קודי הפורמט שהכי כדאי לזכור:

• %Y: שנה בארבע ספרות (2026)
• %m: מספר החודש, עם אפס מוביל (04)
• %d: היום בחודש, עם אפס מוביל (20)
• %H / %I: שעה, בפורמט 24 או 12 שעות
• %M: דקה
• %S: שנייה
• %A / %a: שם היום, מלא / מקוצר (Monday / Mon)
• %B / %b: שם החודש, מלא / מקוצר (April / Apr)
• %p: AM/PM

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

פענוח עם strptime

הכיוון ההפוך: לוקחים מחרוזת במבנה ידוע והופכים אותה ל-datetime:

from datetime import datetime

text = "2026-04-20 09:30"
parsed = datetime.strptime(text, "%Y-%m-%d %H:%M")

print(parsed)
print(parsed.year, parsed.hour)

מחרוזת הפורמט חייבת להתאים לקלט בדיוק. אם היא לא מתאימה, strptime זורקת ValueError.

למחרוזות ISO-8601 (התקן שמכונות קוראות) יש קיצור דרך פשוט יותר ב-Python מודרנית:

from datetime import datetime

d = datetime.fromisoformat("2026-04-20T09:30:00")
print(d)

אם אתם מתמודדים עם פורמטים אקראיים, בחבילה החיצונית dateutil (pip install python-dateutil) יש parser.parse() סלחנית שמנחשת ניחוש סביר.

חישובים עם timedelta

כדי לחשב עם תאריכים, השתמשו ב-timedelta עבור ההפרש או ההיסט:

from datetime import date, datetime, timedelta

today = date(2026, 4, 20)
next_week = today + timedelta(days=7)
yesterday = today - timedelta(days=1)

print(next_week, yesterday)

# חיסור של שני תאריכים נותן timedelta.
gap = date(2027, 1, 1) - today
print(gap)
print(gap.days)

הארגומנטים של timedelta: days, seconds, microseconds, milliseconds, minutes, hours, weeks. אין months או years, כי אורך החודשים משתנה. לחישובים של חודשים ושנים, השתמשו ב-dateutil.relativedelta:

from dateutil.relativedelta import relativedelta
from datetime import date

today = date.today()
next_quarter = today + relativedelta(months=3)
print(next_quarter)

אזורי זמן: נאיבי מול מודע

datetime בלי מידע על אזור זמן הוא נאיבי (naive): Python לא יודעת איזה אזור זמן הוא מייצג. חישובי זמן על datetimes נאיביים הם בסדר כל עוד נשארים בתוך אזור זמן לוגי אחד; הצרות מתחילות ברגע שנתונים מאזורים שונים נפגשים.

datetime מודע (aware) נושא איתו את המידע על אזור הזמן. צרפו אזור זמן במפורש:

from datetime import datetime, timezone, timedelta

utc_now = datetime.now(timezone.utc)
print(utc_now)
print(utc_now.tzinfo)

Python 3.9 הוסיפה את המודול zoneinfo לאזורי זמן לפי שם (בעזרת מסד הנתונים IANA של המערכת):

from datetime import datetime
from zoneinfo import ZoneInfo

now_tokyo = datetime.now(ZoneInfo("Asia/Tokyo"))
now_ny = datetime.now(ZoneInfo("America/New_York"))

print(now_tokyo)
print(now_ny)
print(now_tokyo - now_ny)   # ה-timedelta קרוב לאפס: אותו רגע, שעונים שונים

ממירים בין אזורים עם .astimezone():

from datetime import datetime
from zoneinfo import ZoneInfo

utc = datetime(2026, 4, 20, 12, 0, tzinfo=ZoneInfo("UTC"))
berlin = utc.astimezone(ZoneInfo("Europe/Berlin"))

print(utc)
print(berlin)

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

חותמות זמן

חותמת זמן של Unix היא מספר השניות מאז 1970-01-01 UTC. Python ממירה בקלות:

from datetime import datetime, timezone

now = datetime.now(timezone.utc)
ts = now.timestamp()

print(ts)
print(datetime.fromtimestamp(ts, tz=timezone.utc))

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

מדידה של כמה זמן משהו לוקח

למדידות מהירות, מחסרים שני datetimes:

from datetime import datetime
import time

start = datetime.now()
time.sleep(0.2)
elapsed = datetime.now() - start

print(elapsed.total_seconds())

למדידת ביצועים רצינית יותר, השתמשו ב-time.perf_counter(): יש לה רזולוציה של פחות ממיקרו-שנייה והיא חסינה לשינויים בשעון המערכת. datetime.now() מתאימה למספרים בסגנון "כמה זמן לקחה הקריאה ל-API".

דפוסים שתשתמשו בהם שוב

from datetime import date, datetime, timedelta, timezone

# התאריך של היום בפורמט ISO
print(date.today().isoformat())

# גיל בשנים (בערך, לא מדויק בגלל שנים מעוברות)
dob = date(1990, 7, 15)
days_old = (date.today() - dob).days
print(days_old // 365, "years old")

# תחילת השעה הנוכחית ב-UTC
now = datetime.now(timezone.utc)
start_of_hour = now.replace(minute=0, second=0, microsecond=0)
print(start_of_hour)

# לפני שבעה ימים
print(date.today() - timedelta(days=7))

מה לקחת מכאן

• date, datetime ו-timedelta מכסים 90% מהצרכים.
• השתמשו ב-ISO-8601 לפלט שמכונות קוראות, וב-strftime לפלט שבני אדם קוראים.
• שמרו ב-UTC; המירו בזמן התצוגה.
• השתמשו ב-zoneinfo לאזורי זמן לפי שם.
• לחודשים ולשנים, השתמשו ב-dateutil.relativedelta.

עוד כלי אחד לארגז הכלים המעשי שלכם: ביטויים רגולריים, בהמשך.