Python Date & Time — datetime, Epoch Timestamps & Format Conversions

The Story That Explains Time in Python ⏰Python में समय समझाने वाली कहानी ⏰一个讲清 Python 时间的故事 ⏰

This tutorial focuses on the conversions you will do most: turning a human-readable string into a Unix timestamp, and turning that number back into any format you want. They sit behind every log parser, database write, API response and scheduled job.

यह tutorial उन बदलावों पर ध्यान देता है जो आप सबसे ज़्यादा करेंगे: इंसान के पढ़ने लायक string को Unix timestamp में बदलना, और उस नंबर को वापस किसी भी format में लाना। हर log parser, database write, API response और scheduled job के पीछे यही होता है।

本教程聚焦你最常做的转换：把 人类可读的字符串 变成 Unix 时间戳，再把这个数字变回任何你想要的格式。每个日志解析器、数据库写入、API 响应和定时任务背后都是它们。

Python's Three Time Modules 🧰Python के तीन Time Modules 🧰Python 的三个时间模块 🧰

Here is "what time is it right now?" from four angles. This example uses the real clock, so your output will show your own date and time.

"अभी कितने बजे हैं?" चार नज़रियों से। यह उदाहरण असली घड़ी इस्तेमाल करता है, इसलिए आपके output में आपकी अपनी तारीख़ और समय होगा।

从四个角度回答"现在几点？"。这个例子使用真实时钟，所以你的输出会显示你自己的日期和时间。

from datetime import datetime
import time

now = datetime.now()                  # the real clock - your output will differ
print(now)                            # a datetime object
print(time.time())                    # a Unix timestamp (seconds since 1970)
print(now.isoformat())                # an ISO 8601 string
print(now.strftime("%A, %d %B %Y"))   # a string in your own layout

The Unix Epoch — Counting Seconds Since 1970 🔢Unix Epoch — 1970 से सेकंड गिनना 🔢Unix 纪元 — 从 1970 年开始数秒 🔢

A Unix timestamp (or epoch time) is the number of seconds since a fixed starting point: 1 January 1970, 00:00:00 UTC. That point is called the epoch. Unix was being built around then, and one plain number was the simplest way to store time: no time zones, no month names, easy to compare and sort. Databases, log files, APIs and file systems still use it.

Unix timestamp (या epoch time) एक तय शुरुआती बिंदु से बीते सेकंडों की संख्या है: 1 जनवरी 1970, 00:00:00 UTC। उस बिंदु को epoch कहते हैं। Unix उसी समय बन रहा था, और समय रखने का सबसे आसान तरीका एक सादा नंबर था: कोई time zone नहीं, कोई महीने का नाम नहीं, तुलना और sort करना आसान। Databases, log files, APIs और file systems आज भी इसे इस्तेमाल करते हैं।

Unix 时间戳（或 纪元时间）是从一个固定起点开始经过的秒数：1970 年 1 月 1 日 00:00:00 UTC。这个起点叫作 纪元（epoch）。Unix 正是那时诞生的，用一个普通数字存储时间最简单：没有时区，没有月份名称，易于比较和排序。数据库、日志文件、API 和文件系统至今仍在使用它。

Try It — Epoch Explorerकरके देखें — Epoch Explorer动手试试 — 纪元探索器

Drag the slider or pick a landmark. You see the same number as a UTC time, as Indian time (UTC+5:30), and as the 32 bits an old system would store. Press Play to watch the ticker tape run, then speed it up. Jump to Y2038 max, play at real speed, and watch the red sign bit flip.

Slider खींचें या कोई landmark चुनें। आप वही नंबर UTC समय, भारतीय समय (UTC+5:30), और उन 32 bits के रूप में देखेंगे जो पुराना system रखता। टिकर टेप चलते देखने के लिए Play दबाएँ, फिर रफ़्तार बढ़ाएँ। Y2038 max पर जाएँ, असली रफ़्तार से चलाएँ, और लाल sign bit पलटते देखें।

拖动滑块或选择一个里程碑。你会看到同一个数字作为 UTC 时间、印度时间（UTC+5:30）以及老系统会存储的 32 位二进制。按 播放 看计数纸带走动，再调快速度。跳到 Y2038 max，以真实速度播放，看红色符号位翻转。

The Conversion Triangle 🔺बदलाव का त्रिकोण 🔺转换三角 🔺

Remember this picture. A moment can be a string, a datetime object or a timestamp, and each arrow has a named function. The datetime object sits in the middle: strings and timestamps always pass through it.

यह तस्वीर याद रखें। एक पल string, datetime object या timestamp हो सकता है, और हर तीर का एक नाम वाला function है। Datetime object बीच में है: strings और timestamps हमेशा इसी से होकर गुज़रते हैं।

记住这张图。一个时刻可以是 字符串、datetime 对象 或 时间戳，每个箭头都有对应的函数。datetime 对象位于中间：字符串和时间戳总要经过它。

Human String ↔ datetime 🔁इंसानी String ↔ datetime 🔁人类字符串 ↔ datetime 🔁

String → datetime with strptime()strptime() से String → datetime用 strptime() 把字符串变成 datetime

strptime means "string parse time". You give it the text and a format that describes exactly how the text is laid out. Python matches the two and returns a datetime.

strptime का मतलब है "string parse time"। आप इसे text और एक format देते हैं जो बताता है कि text ठीक-ठीक कैसे लिखा है। Python दोनों को मिलाता है और datetime लौटाता है।

strptime 意为 "string parse time"。你给它文本 和 一个准确描述文本布局的格式。Python 把两者对照，返回一个 datetime。

from datetime import datetime

dt = datetime.strptime("2026-07-12 14:30:00", "%Y-%m-%d %H:%M:%S")
print(dt)
print(type(dt))

dt2 = datetime.strptime("12/Jul/2026", "%d/%b/%Y")
print(dt2)

print(dt.year, dt.month, dt.day)
print(dt.weekday(), dt.strftime("%A"))      # Monday is 0, so Sunday is 6

datetime → String with strftime()strftime() से datetime → String用 strftime() 把 datetime 变成字符串

strftime means "string format time". It uses the same %-codes, but goes the other way. Here we fix "now" to one moment so the output is the same every time.

strftime का मतलब है "string format time"। यह वही %-codes इस्तेमाल करता है, पर उल्टी दिशा में। यहाँ हमने "now" को एक तय पल पर रखा है ताकि output हर बार एक जैसा रहे।

strftime 意为 "string format time"。它使用同样的 % 代码，但方向相反。这里我们把"现在"固定为某一时刻，让输出每次都一样。

from datetime import datetime

now = datetime(2026, 7, 12, 14, 30, 15)     # a fixed "now", so the output repeats

print(now.strftime("%Y-%m-%d"))             # ISO date
print(now.strftime("%Y-%m-%d %H:%M:%S"))    # ISO date and time
print(now.strftime("%d/%m/%Y"))             # India / UK style
print(now.strftime("%m/%d/%Y"))             # US style
print(now.strftime("%A, %d %B %Y"))
print(now.strftime("%d %b '%y"))
print(now.strftime("%I:%M %p"))             # 12-hour clock
print(now.strftime("backup_%Y%m%d_%H%M%S.zip"))

The Format Code Reference 📋Format Code संदर्भ 📋格式代码参考 📋

strptime and strftime share one vocabulary of %-codes. The examples below are real Python output for datetime(2026, 7, 12, 14, 30, 15, 123456, tzinfo=ZoneInfo("Asia/Kolkata")) — a Sunday.

strptime और strftime %-codes की एक ही शब्दावली बाँटते हैं। नीचे के उदाहरण datetime(2026, 7, 12, 14, 30, 15, 123456, tzinfo=ZoneInfo("Asia/Kolkata")) — एक रविवार — के लिए असली Python output हैं।

strptime 和 strftime 共用一套 % 代码。下面的示例是 datetime(2026, 7, 12, 14, 30, 15, 123456, tzinfo=ZoneInfo("Asia/Kolkata"))（星期日）的真实 Python 输出。

Try It — strftime Builderकरके देखें — strftime Builder动手试试 — strftime 构建器

Type a format, or click codes to add them. Each code turns into its own coloured piece of the result. Try the presets, switch the moment and the time zone, and try the "bug" preset to see a classic mistake.

Format लिखें, या codes पर click करके जोड़ें। हर code नतीजे के अपने रंगीन हिस्से में बदलता है। Presets आज़माएँ, पल और time zone बदलें, और एक आम ग़लती देखने के लिए "bug" preset आज़माएँ।

输入一个格式，或点击代码添加。每个代码都会变成结果中一块带颜色的片段。试试预设，切换时刻和时区，再试试"bug"预设，看一个经典错误。

Try It — strptime Matcherकरके देखें — strptime Matcher动手试试 — strptime 匹配器

strptime walks along the format and the text together. Step through ten real cases and watch which characters each code reads. Every result and error message below is exactly what Python 3.13 gave.

strptime format और text पर साथ-साथ चलता है। दस असली मामलों में कदम-दर-कदम चलें और देखें हर code कौन-से अक्षर पढ़ता है। नीचे का हर नतीजा और error message ठीक वही है जो Python 3.13 ने दिया।

strptime 沿着格式和文本同步前进。逐步查看十个真实案例，看每个代码读取了哪些字符。下面每个结果和错误信息都与 Python 3.13 给出的完全一致。

datetime ↔ Unix Timestamp 🔄datetime ↔ Unix Timestamp 🔄datetime ↔ Unix 时间戳 🔄

datetime → Timestamp with .timestamp().timestamp() से datetime → Timestamp用 .timestamp() 把 datetime 变成时间戳

All the examples from here on were run on a computer set to India time (Asia/Kolkata, UTC+5:30). That matters, as you are about to see.

यहाँ से आगे के सारे उदाहरण भारतीय समय (Asia/Kolkata, UTC+5:30) पर set कंप्यूटर पर चलाए गए। यह मायने रखता है, जैसा आप अभी देखेंगे।

从这里开始的所有示例都在设置为 印度时间（Asia/Kolkata，UTC+5:30） 的电脑上运行。这一点很重要，你马上就会看到。

from datetime import datetime, timezone

aware = datetime(2026, 7, 12, 14, 30, tzinfo=timezone.utc)
ts = aware.timestamp()
print(ts, type(ts).__name__)        # a float
print(int(ts))

naive = datetime(2026, 7, 12, 14, 30)   # no time zone!
print(int(naive.timestamp()))           # Python assumes LOCAL time (here: India, UTC+5:30)
print(int(aware.timestamp()) - int(naive.timestamp()))   # 19800 s = 5 h 30 min

Timestamp → datetime with fromtimestamp()fromtimestamp() से Timestamp → datetime用 fromtimestamp() 把时间戳变成 datetime

from datetime import datetime, timezone

ts = 1783866600

print(datetime.fromtimestamp(ts))                    # local time (this computer: India)
print(datetime.fromtimestamp(ts, tz=timezone.utc))   # UTC - same moment, different clock

Same moment, two clocks: 14:30 in UTC is 20:00 in India. Without tz, you get a naive local time with no label — easy to misread later.

एक ही पल, दो घड़ियाँ: UTC का 14:30 भारत का 20:00 है। tz के बिना आपको बिना label का naive local समय मिलता है — बाद में ग़लत पढ़ना आसान।

同一时刻，两只钟：UTC 的 14:30 就是印度的 20:00。不传 tz，你得到的是没有标签的 naive 本地时间 — 以后很容易读错。

The Full Recipe — String ↔ Epoch in One Go 🍳पूरी Recipe — एक बार में String ↔ Epoch 🍳完整配方 — 一步完成字符串 ↔ 纪元 🍳

This is what most people need: a human date straight to a timestamp, and a timestamp from a database straight to any display format. Both are two steps through the datetime hub, and both say clearly that the time is UTC.

ज़्यादातर लोगों को यही चाहिए: इंसानी तारीख़ सीधे timestamp में, और database का timestamp सीधे किसी भी display format में। दोनों datetime hub से होकर दो कदम हैं, और दोनों साफ़ कहते हैं कि समय UTC है।

这是大多数人需要的：把人类日期直接变成时间戳，把数据库里的时间戳直接变成任意显示格式。两者都是经过 datetime 枢纽的两步，并且都明确说明时间是 UTC。

from datetime import datetime, timezone

def to_epoch(text, fmt="%Y-%m-%d %H:%M:%S"):
    """Human-readable string (meant as UTC) -> Unix timestamp."""
    dt = datetime.strptime(text, fmt)
    dt = dt.replace(tzinfo=timezone.utc)     # say clearly: this is UTC
    return int(dt.timestamp())

def from_epoch(ts, fmt="%Y-%m-%d %H:%M:%S"):
    """Unix timestamp -> string, shown in UTC."""
    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime(fmt)

ts = to_epoch("2026-07-12 14:30:00")
print(ts)
print(to_epoch("12/Jul/2026 14:30", fmt="%d/%b/%Y %H:%M"))
print(to_epoch("2000-01-01 00:00:00"))           # Y2K

print(from_epoch(ts))
print(from_epoch(ts, "%A, %d %B %Y at %I:%M %p"))
print(from_epoch(ts, "%d/%m/%Y"))
print(from_epoch(ts, "backup_%Y%m%d_%H%M%S.log"))

Bonus — ISO 8601 with fromisoformat()Bonus — fromisoformat() के साथ ISO 8601附加 — 用 fromisoformat() 处理 ISO 8601

If the text is in ISO 8601 form (like 2026-07-12T14:30:00Z), you do not need a format string at all. Since Python 3.11, fromisoformat() accepts almost every ISO 8601 form, including the Z for UTC.

अगर text ISO 8601 रूप में है (जैसे 2026-07-12T14:30:00Z), तो format string की ज़रूरत ही नहीं। Python 3.11 से fromisoformat() लगभग हर ISO 8601 रूप स्वीकार करता है, UTC वाले Z समेत।

如果文本是 ISO 8601 格式（如 2026-07-12T14:30:00Z），根本不需要格式字符串。从 Python 3.11 起，fromisoformat() 几乎接受所有 ISO 8601 形式，包括表示 UTC 的 Z。

from datetime import datetime

# Python 3.11+: fromisoformat() reads almost any ISO 8601 string, including "Z"
print(datetime.fromisoformat("2026-07-12T14:30:00Z"))
print(datetime.fromisoformat("2026-07-12T20:00:00+05:30"))
print(datetime.fromisoformat("20260712T143000"))

dt = datetime.fromisoformat("2026-07-12T14:30:00+00:00")
print(dt.isoformat())        # and back again - a safe format for APIs and files

The time Module — Clocks and Stopwatches ⏱️time Module — घड़ियाँ और स्टॉपवॉच ⏱️time 模块 — 时钟与秒表 ⏱️

import time

print(type(time.time()).__name__)      # wall clock: float seconds since 1970

start = time.perf_counter()            # a stopwatch: only differences matter
time.sleep(0.25)
elapsed = time.perf_counter() - start
print(f"Elapsed: {elapsed:.2f}s")

t = time.gmtime(1783866600)            # timestamp -> struct_time in UTC
print(t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min)
print(time.strftime("%Y-%m-%d %H:%M:%S", t))
print(time.monotonic() > 0)            # another clock that never goes backwards

Time Zones — Naive vs Aware 🌍Time Zones — Naive बनाम Aware 🌍时区 — naive 与 aware 🌍

A naive datetime does not know its time zone. An aware datetime does. Mixing the two is the most common source of date bugs, and Python refuses to compare or subtract them.

Naive datetime को अपना time zone नहीं पता। Aware datetime को पता है। दोनों को मिलाना date bugs की सबसे आम वजह है, और Python इनकी तुलना या घटाने से मना करता है।

naive datetime 不知道自己的时区，aware datetime 知道。混用两者是日期 bug 最常见的来源，Python 拒绝比较或相减它们。

from datetime import datetime, timezone, timedelta
from zoneinfo import ZoneInfo

naive = datetime(2026, 7, 12, 14, 30)
print(naive, naive.tzinfo)

aware = datetime(2026, 7, 12, 14, 30, tzinfo=timezone.utc)
print(aware, aware.tzinfo)

ist = ZoneInfo("Asia/Kolkata")
print(aware.astimezone(ist))                         # same moment, Indian clock
print(aware.astimezone(ZoneInfo("Asia/Shanghai")))
print(aware.astimezone(ZoneInfo("America/New_York")))

fixed = timezone(timedelta(hours=5, minutes=30))     # a fixed offset, no name rules
print(aware.astimezone(fixed))

try:
    print(aware - naive)
except TypeError as e:
    print("TypeError:", e)

Try It — Time Zone Clockकरके देखें — Time Zone Clock动手试试 — 时区时钟

Six cities, one moment. Slide through a day in 30-minute steps or press Play. Pick 8 March 2026 and watch New York jump from 01:30 to 03:00; pick 1 November 2026 and watch it show 01:30 twice. India, China and Japan have no daylight saving time, so their clocks never jump. All values come from Python's zoneinfo.

छह शहर, एक पल। 30 मिनट के कदमों में दिन पर slide करें या Play दबाएँ। 8 मार्च 2026 चुनें और New York को 01:30 से 03:00 पर कूदते देखें; 1 नवंबर 2026 चुनें और उसे दो बार 01:30 दिखाते देखें। भारत, चीन और जापान में daylight saving time नहीं है, इसलिए उनकी घड़ियाँ कभी नहीं कूदतीं। सारी values Python के zoneinfo से आई हैं।

六座城市，同一时刻。以 30 分钟为步长拖过一天，或按 播放。选 2026 年 3 月 8 日，看纽约从 01:30 跳到 03:00；选 2026 年 11 月 1 日，看它两次显示 01:30。印度、中国和日本没有夏令时，所以时钟从不跳变。所有数值都来自 Python 的 zoneinfo。

Daylight Saving: Times That Do Not Exist, and Times That Happen TwiceDaylight Saving: जो समय होते ही नहीं, और जो दो बार होते हैं夏令时：不存在的时间，和出现两次的时间

from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

ny = ZoneInfo("America/New_York")

# 8 March 2026: New York clocks jump from 02:00 straight to 03:00
gap = datetime(2026, 3, 8, 2, 30, tzinfo=ny)
print(gap.astimezone(ZoneInfo("UTC")).astimezone(ny))    # 02:30 does not exist

# 1 November 2026: clocks go back, so 01:30 happens TWICE
first  = datetime(2026, 11, 1, 1, 30, tzinfo=ny, fold=0)
second = datetime(2026, 11, 1, 1, 30, tzinfo=ny, fold=1)
print(first, first.tzname())
print(second, second.tzname())
print(second.timestamp() - first.timestamp())            # 3600.0 seconds apart

fold=0 picks the first 01:30 (still summer time, EDT), fold=1 the second one (winter time, EST). They are one hour apart, though the wall clock reads the same.

fold=0 पहला 01:30 चुनता है (अब भी गर्मी का समय, EDT), fold=1 दूसरा (सर्दी का समय, EST)। दीवार की घड़ी एक ही समय दिखाती है, फिर भी ये एक घंटे के अंतर पर हैं।

fold=0 选择第一个 01:30（仍是夏令时 EDT），fold=1 选择第二个（冬令时 EST）。挂钟读数相同，实际却相差一小时。

Time Arithmetic with timedelta ➕timedelta से समय की गणना ➕用 timedelta 做时间运算 ➕

A timedelta is a duration. Add it to a datetime to move forward, subtract it to move back. Subtracting two datetimes gives a timedelta.

timedelta एक अवधि है। आगे जाने के लिए इसे datetime में जोड़ें, पीछे जाने के लिए घटाएँ। दो datetimes घटाने पर timedelta मिलता है।

timedelta 表示一段 时长。加到 datetime 上向前移动，减去则向后移动。两个 datetime 相减得到 timedelta。

from datetime import datetime, timedelta

now = datetime(2026, 7, 12, 14, 30)    # a fixed "now"

print(now + timedelta(days=1))
print(now + timedelta(weeks=1))
print(now + timedelta(minutes=90))
print(now - timedelta(days=1))

custom = timedelta(days=2, hours=3, minutes=30, seconds=45)
print(custom)                  # str: "2 days, 3:30:45"
print(repr(custom))            # stored as days + seconds only
print(now + custom)

print(timedelta(hours=-1))     # negative: -1 day + 23 hours!

until = datetime(2026, 12, 25) - now
print(f"Days until Christmas: {until.days}")
print(f"Total seconds:        {until.total_seconds():.0f}")

Try It — timedelta Calculatorकरके देखें — timedelta Calculator动手试试 — timedelta 计算器

Type weeks, days, hours and minutes (negative numbers too). Watch how Python stores and prints the result, and where it lands on the ±30-day ruler.

Weeks, days, hours और minutes लिखें (negative नंबर भी)। देखें Python नतीजे को कैसे रखता और छापता है, और वह ±30 दिन के पैमाने पर कहाँ पहुँचता है।

输入周、天、小时和分钟（也可以是负数）。看看 Python 如何存储和打印结果，以及它落在 ±30 天尺子上的哪里。

Practical Real-World Examples 🛠️असली काम के उदाहरण 🛠️实战示例 🛠️

Each example takes "today" or "now" as an argument instead of reading the clock inside. That makes the function easy to test — and the output below repeatable.

हर उदाहरण घड़ी को अंदर पढ़ने के बजाय "today" या "now" को argument के रूप में लेता है। इससे function को test करना आसान होता है — और नीचे का output दोहराने योग्य रहता है।

每个示例都把"今天"或"现在"作为参数传入，而不是在函数内部读时钟。这样函数容易测试 — 下面的输出也可重复。

1 · Age from Date of Birth1 · जन्मतिथि से उम्र1 · 根据出生日期计算年龄

from datetime import date

def age(dob_text, today):
    dob = date.fromisoformat(dob_text)
    years = today.year - dob.year
    if (today.month, today.day) < (dob.month, dob.day):    # birthday not yet this year
        years -= 1
    return years

today = date(2026, 7, 12)
print(age("1990-03-15", today))    # birthday already passed
print(age("1990-11-20", today))    # birthday still to come

2 · Countdown2 · उलटी गिनती2 · 倒计时

from datetime import datetime

def countdown(target_text, now):
    target = datetime.strptime(target_text, "%Y-%m-%d %H:%M")
    delta = target - now
    if delta.total_seconds() < 0:
        return "That moment has passed!"
    hours, rem = divmod(delta.seconds, 3600)
    return f"{delta.days}d {hours}h {rem // 60}m remaining"

now = datetime(2026, 7, 12, 14, 30)
print(countdown("2026-12-31 23:59", now))
print(countdown("2026-01-01 00:00", now))

3 · Parse Log Timestamps3 · Log Timestamps parse करना3 · 解析日志时间戳

from datetime import datetime

log_lines = [
    "[2026-07-12 14:30:15] User logged in",
    "[2026-07-12 14:31:02] File uploaded",
    "[2026-07-12 14:35:47] Session expired",
]

events = []
for line in log_lines:
    stamp, message = line[1:20], line[22:]
    events.append((datetime.strptime(stamp, "%Y-%m-%d %H:%M:%S"), message))

for (t1, m1), (t2, m2) in zip(events, events[1:]):
    print(f"{m1!r} -> {m2!r}: {t2 - t1}")
duration = events[-1][0] - events[0][0]
print(f"Session lasted {duration.total_seconds():.0f} seconds ({duration})")

4 · Between an API and a User4 · API और User के बीच4 · 在 API 与用户之间

from datetime import datetime, timezone

# An API sent this JSON: {"created_at": 1783866600}
created = datetime.fromtimestamp(1783866600, tz=timezone.utc)
print(f"Created: {created.strftime('%d %b %Y, %H:%M UTC')}")

# A user typed "31/12/2026" - save it as a UTC timestamp
dt_user = datetime.strptime("31/12/2026", "%d/%m/%Y").replace(tzinfo=timezone.utc)
epoch_to_save = int(dt_user.timestamp())
print(f"Saving: {epoch_to_save}")
print("Check :", datetime.fromtimestamp(epoch_to_save, tz=timezone.utc))

5 · Timestamped File Names5 · Timestamp वाले File नाम5 · 带时间戳的文件名

from datetime import datetime

now = datetime(2026, 7, 12, 14, 30, 15)
print(now.strftime("export_%Y%m%d_%H%M%S.csv"))
print(now.strftime("backup-%Y-%m-%d.tar.gz"))

# Names in this format sort in time order, even as plain text
names = ["export_20261201.csv", "export_20260712.csv", "export_20260105.csv"]
print(sorted(names))

6 · Dates Without a Year — A Change in Python 3.156 · बिना साल की तारीख़ें — Python 3.15 में बदलाव6 · 没有年份的日期 — Python 3.15 的变化

import warnings
from datetime import datetime
warnings.simplefilter("always")        # show the warning every time

# Day and month, but NO year:
try:
    print(datetime.strptime("29 Feb", "%d %b"))
except ValueError as e:
    print("ValueError:", e)

# The fix: add a leap year yourself, then use only day and month
d = datetime.strptime("29 Feb 2000", "%d %b %Y")
print(d.day, d.month)

Common Pitfalls 🕳️आम ग़लतियाँ 🕳️常见陷阱 🕳️

Quick Reference, Golden Rules and Quiz 🏆झटपट संदर्भ, सुनहरे नियम और Quiz 🏆速查、黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题