Python datetime: Python में तिथि और समय के साथ कैसे काम करें

तिथियों और समय के साथ काम करना सरल लगता है, जब तक कि आप फ़ॉर्मेट, समय क्षेत्र, डेलाइट सेविंग नियम, या कई सिस्टमों से आने वाले टाइमस्टैम्प से नहीं जूझते—ऐसे में समय को कच्चे स्ट्रिंग या इंटीजर के रूप में रखना विकल्प नहीं रहता। Python का datetime मॉड्यूल इन सभी बदलती चीज़ों को अनुमानित तरीके से प्रबंधित करने में आपकी मदद करने के लिए मौजूद है।

यह गाइड मुख्य क्लासों, datetime ऑब्जेक्ट बनाने और उनके साथ काम करने, गणितीय क्रियाएँ करने, मानों को फ़ॉर्मेट और पार्स करने, समय क्षेत्रों को संभालने, और बहुत कुछ के बारे में बताता है। हर अनुभाग पिछले पर आधारित है, ताकि आप बुनियादी ऑपरेशनों से उन्नत पैटर्न तक सहजता से आगे बढ़ सकें।

Python datetime मॉड्यूल की मुख्य क्लासें

कुछ भी विशेष करने से पहले, यह समझना उपयोगी है कि Python संकल्पनात्मक स्तर पर तिथियों और समय को कैसे मॉडल करता है। datetime मॉड्यूल कुछ ही क्लासें उपयोग करता है, जिनमें से प्रत्येक समस्या के एक हिस्से पर केंद्रित है। किस क्लास की जगह कहाँ है, यह जानना बाकी वर्कफ़्लो को बहुत आसान बना देता है।

date

जब आपको केवल कैलेंडर तिथि चाहिए—दिन के समय या समय क्षेत्र की चिंता किए बिना—तो date क्लास काम आती है। यह वर्ष, माह और दिन को परिचित एट्रिब्यूट्स के रूप में दर्शाती है।

ये एट्रिब्यूट्स हैं:

• year

• month

• day

और ये मेथड्स हैं:

• today()

• fromisoformat()

• replace()

• isoformat()

• weekday()

• isoweekday()

from datetime import date
d = date(2025, 3, 1)
print(d)संचालित द्वारा

यह कोड एक साधारण कैलेंडर तिथि बनाता है। यदि आप कोई अमान्य संयोजन दर्ज करते हैं (जैसे February 30), तो Python ValueError नामक त्रुटि उठाता है।

time

कुछ कार्यों में केवल दिन का समय मायने रखता है, जैसे 2:30 PM पर चलने वाली रिमाइंडर। time क्लास सहायक है क्योंकि यह घंटे, मिनट, सेकंड और (इस उदाहरण के लिए आवश्यक नहीं) माइक्रोसेकंड या टाइमज़ोन डेटा संग्रहीत करता है।

एट्रिब्यूट्स हैं: hour, minute, second, microsecond, tzinfo

मेथड्स हैं: replace(), isoformat()

from datetime import time
t = time(14, 30, 15)
print(t)संचालित द्वारा

यह बिना किसी तिथि के एक घड़ी समय बनाता है। अमान्य मान (जैसे hour=27) त्रुटि उत्पन्न करेंगे।

datetime

अधिकांश वास्तविक दुनिया की स्थितियों में तिथि और समय दोनों की ज़रूरत होती है, और वहीं datetime काम आता है। यह मॉड्यूल की सबसे बहुमुखी क्लास है और लॉगिंग, प्रोसेसिंग, और इवेंट समन्वय के लिए आप इसे सबसे अधिक उपयोग करेंगे।

एट्रिब्यूट्स हैं (ऊपर बताए गए सभी के अतिरिक्त): tzinfo

और मेथड्स हैं now(), utcnow(), fromisoformat(), strptime(), strftime(), astimezone()। यह timedelta के साथ अंकगणित का भी समर्थन करता है, जिसे मैं आगे विस्तार से बताऊँगा।

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt)संचालित द्वारा

यह तिथि और समय दोनों घटकों के साथ एक पूर्ण टाइमस्टैम्प बनाता है।

timedelta

जब भी आपको बीता हुआ समय मापना हो या किसी टाइमस्टैम्प को आगे-पीछे शिफ्ट करना हो, timedelta सही विकल्प है। यह अवधि को दर्शाता है, न कि किसी विशिष्ट क्षण को।

एट्रिब्यूट्स हैं: days, seconds, microseconds। इसे आम तौर पर ऑफ़सेट, समयांतर और शेड्यूलिंग लॉजिक के लिए उपयोग किया जाता है।

from datetime import timedelta
delta = timedelta(days=7, hours=3)
print(delta)संचालित द्वारा

यह एक निश्चित-लंबाई की अवधि का प्रतिनिधित्व करता है। इसे किसी datetime में जोड़ने या घटाने पर यह विशेष रूप से उपयोगी हो जाता है।

tzinfo

tzinfo Python में समय क्षेत्रों के लिए इंटरफ़ेस परिभाषित करता है। आप इन्हें सीधे नहीं बनाएंगे, लेकिन जब भी आप टाइमज़ोन जोड़ते या कनवर्ट करते हैं, datetime सिस्टम इन्हें उपयोग करता है।

timezone

timezone फिक्स्ड UTC ऑफ़सेट्स (जैसे UTC या UTC+1) के लिए एक बिल्ट-इन tzinfo इम्प्लीमेंटेशन है। यह उन सरल मामलों में उपयोगी है जहाँ डेलाइट सेविंग नियम मायने नहीं रखते।

Python datetime ऑब्जेक्ट बनाना और एक्सेस करना

एक बार क्लासें समझ लेने के बाद अगला कदम उनके इंस्टेंस बनाना सीखना है। Python आपके डेटा के स्रोत—मैनुअल एंट्री, सिस्टम समय, टाइमस्टैम्प, या टेक्स्ट—के अनुसार कई तरीके देता है।

क्लास कंस्ट्रक्टर का उपयोग

कंस्ट्रक्टर आपको बनाए जा रहे मानों पर पूरा नियंत्रण देते हैं। यह अक्सर तिथि, समय, या datetime ऑब्जेक्ट बनाने का सबसे स्पष्ट और त्रुटि-रोधी तरीका होता है।

from datetime import date
d = date(2025, 3, 1)
print(d)संचालित द्वारा

यह सीधे एक कैलेंडर तिथि बनाता है। अमान्य मान तुरंत त्रुटि उठाते हैं, जिससे शुरुआती चरण में ही गलतियाँ पकड़ में आती हैं।

from datetime import time
t = time(14, 30, 15)
print(t)संचालित द्वारा

यह दिन-के-समय का मान बनाता है। जब आपको तिथि जोड़ने की ज़रूरत न हो, तब इसका उपयोग करें।

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt)संचालित द्वारा

यह एक पूरा टाइमस्टैम्प बनाता है। tzinfo आर्ग्युमेंट जोड़ने पर यह टाइमज़ोन-अवेयर बन जाता है।

टाइमस्टैम्प से बनाना

Unix टाइमस्टैम्प लॉग, API, और ऑपरेटिंग सिस्टम में आम हैं। Python इन्हें आसानी से इंसानी-पढ़ने योग्य datetime ऑब्जेक्ट में बदल देता है।

datetime.fromtimestamp(1700000000)
datetime.utcfromtimestamp(1700000000)संचालित द्वारा

पहला टाइमस्टैम्प को लोकल समय में समझता है; दूसरा उसे UTC में समझता है।

वर्तमान मानों के लिए क्लास मेथड्स

जब आपको मौजूदा तिथि या समय चाहिए, Python सरल हेल्पर्स देता है। लॉगिंग, इवेंट ट्रैकिंग और रीयल-टाइम पाइपलाइनों के लिए ये आवश्यक हैं।

from datetime import datetime, date, timezone
print(date.today())
print(datetime.now())
print(datetime.now(tz=timezone.utc))  # Python 3.12+ preferredसंचालित द्वारा

ये आपको वर्तमान सिस्टम समय देते हैं—आपकी ज़रूरत के अनुसार लोकल समय या UTC में।

datetime.fromtimestamp(1700000000)
datetime.utcfromtimestamp(1700000000)संचालित द्वारा

ये एपोक टाइमस्टैम्प को datetime ऑब्जेक्ट में बदलते हैं। API या डेटाबेस मानों को पार्स करते समय ये अत्यंत सामान्य हैं।

स्ट्रिंग से पार्स करना

वास्तविक दुनिया के डेटासेट अक्सर टाइमस्टैम्प को टेक्स्ट के रूप में संग्रहीत करते हैं। Python उन स्ट्रिंग्स को संरचित मानों में बदलने के लिए भरोसेमंद टूल्स देता है।

strptime()
from datetime import datetime
dt = datetime.strptime("2025-03-01 14:30", "%Y-%m-%d %H:%M")
print(dt)संचालित द्वारा

strptime() किसी पैटर्न का उपयोग करके स्ट्रिंग पार्स करता है। यदि स्ट्रिंग बिल्कुल मेल न खाए, तो Python ValueError उठाता है।

from datetime import datetime
dt = datetime.strptime("not-a-date", "%Y-%m-%d")संचालित द्वारा

यह विफल होगा क्योंकि इनपुट अपेक्षित पैटर्न से मेल नहीं खाता।

fromisoformat()
datetime.fromisoformat("2025-03-01T14:30:00")संचालित द्वारा

ISO 8601 स्ट्रिंग्स साफ़-सुथरे तरीके से पार्स होती हैं क्योंकि संरचना मानकीकृत है। यह अक्सर API या आधुनिक डेटा पाइपलाइनों से टाइमस्टैम्प लोड करने का सबसे आसान तरीका है।

दिनांक गणित करना

एक बार जब आप टाइमस्टैम्प बना सकें, अगला कदम उनके साथ काम करना है। आप यह अवधि गणना करके, तिथियों को शिफ्ट करके, या अंतरालों की तुलना करके कर सकते हैं।

कालगत गणनाओं के लिए Timedelta

timedelta निश्चित-अवधि वाले कालखंडों जैसे “5 घंटे” या “2 हफ्ते” को मॉडल करता है। ये शेड्यूलिंग, लॉगिंग, और सरल काउंटडाउन के लिए उपयोगी हैं।

from datetime import datetime, timedelta
dt = datetime(2025, 3, 1, 14, 30)
new_dt = dt + timedelta(days=5)
print(new_dt)संचालित द्वारा

यह उदाहरण टाइमस्टैम्प को पाँच दिन आगे शिफ्ट करता है।

start = datetime(2025, 3, 1, 9, 0)
end = datetime(2025, 3, 1, 14, 30)
duration = end - start
print(duration.total_seconds())संचालित द्वारा

यहाँ, दो datetimes को घटाने पर एक timedelta मिलता है, जिसे आप सेकंड, दिन, या घंटे में बदल सकते हैं।

निश्चित-अवधि बनाम कैलेंडर-संज्ञानी गणित

सभी समय इकाइयाँ समान नहीं होतीं। महीनों की लंबाई बदलती है, वर्षों में लीप डे हो सकते हैं, और महीने के अंत का व्यवहार अप्रत्याशित हो सकता है। इन स्थितियों में timedelta पर्याप्त नहीं है।

dateutil.relativedelta “कैलेंडर-संज्ञानी” गणित को संभालता है:

from dateutil.relativedelta import relativedelta
from datetime import date
d = date(2025, 1, 31)
print(d + relativedelta(months=1))संचालित द्वारा

यह “February 31” के अनुपस्थित होने की स्थिति को सही तरीके से हैंडल करता है और तिथि को उपयुक्त रूप से शिफ्ट करता है।

तिथियों का फ़ॉर्मेटिंग और पार्सिंग

Datetime फ़ॉर्मेटिंग हर जगह दिखती है: API विशिष्ट फ़ॉर्मेट्स की अपेक्षा करते हैं, उपयोगकर्ता पठनीय टेक्स्ट पसंद करते हैं, और लॉग सुसंगत टाइमस्टैम्प स्ट्रिंग्स पर निर्भर होते हैं। Python लचीले फ़ॉर्मेटिंग और मानकीकृत अभ्यावेदन दोनों का समर्थन करता है।

strftime के साथ स्ट्रिंग फ़ॉर्मेटिंग

strftime() आपको पूर्वनिर्धारित कोड्स का उपयोग करके datetime ऑब्जेक्ट को फ़ॉर्मेटेड स्ट्रिंग में बदलने देता है।

from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30)
print(dt.strftime("%A, %B %d, %Y at %H:%M"))संचालित द्वारा

यह सप्ताह के दिन और पूर्ण माह नाम के साथ एक मानव-पठनीय स्ट्रिंग प्रिंट करता है।

dt.strftime("%Y-%m-%dT%H:%M:%S")संचालित द्वारा

यह डेटा स्टोरेज या API के लिए उपयुक्त ISO-जैसी स्ट्रिंग देता है।

strptime के साथ स्ट्रिंग पार्स करना

from datetime import datetime
dt = datetime.strptime("2025-03-01 14:30", "%Y-%m-%d %H:%M")
print(dt)संचालित द्वारा

यह टेक्स्ट को datetime ऑब्जेक्ट में बदलता है। स्ट्रिंग और पैटर्न के बीच किसी भी असंगति पर त्रुटि उठती है।

ISO 8601 और RFC 3339 के साथ काम करना

ISO 8601 कई क्षेत्रीय तिथि फ़ॉर्मेट्स में पाई जाने वाली अस्पष्टता को हल करता है। Python इसे बॉक्स से बाहर सपोर्ट करता है:

from datetime import datetime
dt = datetime.fromisoformat("2025-03-01T14:30:00")
print(dt.isoformat())संचालित द्वारा

सिस्टमों, API या डेटाबेस के बीच डेटा का आदान-प्रदान करते समय यह सबसे सुरक्षित फ़ॉर्मेट है।

समय क्षेत्रों को संभालना

समय क्षेत्र कालगत प्रोग्रामिंग में सबसे पेचीदा चुनौतियाँ लाते हैं। Python नाइव और अवेयर datetime ऑब्जेक्ट्स में भेद करके और वास्तविक दुनिया के ज़ोन हैंडलिंग के लिए टूल्स देकर मदद करता है।

Naive बनाम aware datetime ऑब्जेक्ट्स

नाइव datetime में कोई टाइमज़ोन नहीं होता:

from datetime import datetime
naive_dt = datetime(2025, 3, 1, 14, 30)
print(naive_dt.tzinfo)  # Noneसंचालित द्वारा

अवेयर datetime में टाइमज़ोन ऑफ़सेट शामिल होता है:

from datetime import timezone, timedelta
aware_dt = naive_dt.replace(tzinfo=timezone(timedelta(hours=1)))
print(aware_dt)संचालित द्वारा

तुलना या अंकगणित में नाइव और अवेयर मानों को मिलाने से प्रायः त्रुटियाँ होती हैं।

zoneinfo मॉड्यूल का उपयोग

Python का zoneinfo मॉड्यूल वास्तविक IANA टाइमज़ोन्स तक पहुँच देता है:

from zoneinfo import ZoneInfo
from datetime import datetime
dt = datetime(2025, 3, 1, 14, 30, tzinfo=ZoneInfo("Europe/Paris"))
print(dt)संचालित द्वारा

टाइमज़ोन कन्वर्ज़न सरल है:

dt.astimezone(ZoneInfo("America/New_York"))संचालित द्वारा

यह उसी क्षण को किसी अन्य स्थानीय समय क्षेत्र में व्यक्त करता है।

समय क्षेत्रों के बीच रूपांतरण

आप किसी भी अवेयर टाइमस्टैम्प को astimezone() का उपयोग करके दूसरे ज़ोन में बदल सकते हैं:

from zoneinfo import ZoneInfo
dt_ny = dt.astimezone(ZoneInfo("America/New_York"))
print(dt_ny)संचालित द्वारा

एक सामान्य श्रेष्ठ अभ्यास यह है कि टाइमस्टैम्प्स को UTC में संग्रहीत किया जाए और केवल प्रदर्शन के समय आवश्यकतानुसार कन्वर्ट किया जाए।

तिथियों की तुलना और फ़िल्टरिंग

तुलनाएँ लगभग हर वर्कफ़्लो में दिखती हैं—लॉग्स को सॉर्ट करना, इवेंट्स को फ़िल्टर करना, या यह निर्धारित करना कि कुछ किसी सीमा से पहले हुआ या बाद में।

from datetime import datetime
a = datetime(2025, 3, 1, 12, 0)
b = datetime(2025, 3, 1, 15, 0)
print(a < b)  # Trueसंचालित द्वारा

टाइमज़ोन-अवेयर तुलनाएँ ऑफ़सेट्स को ध्यान में रखती हैं:

from datetime import datetime
from zoneinfo import ZoneInfo
dt1 = datetime(2025, 3, 1, 12, 0, tzinfo=ZoneInfo("Europe/London"))
dt2 = datetime(2025, 3, 1, 7, 0, tzinfo=ZoneInfo("America/New_York"))
print(dt1 == dt2)  # True — same moment in timeसंचालित द्वारा

कलेक्शंस को फ़िल्टर करना स्वाभाविक रूप से काम करता है:

dates = [
    datetime(2025, 3, 1, 10),
    datetime(2025, 2, 20, 9),
    datetime(2025, 3, 1, 8)
]
cutoff = datetime(2025, 3, 1)
filtered = [d for d in dates if d >= cutoff]
print(filtered)संचालित द्वारा

ज़ोन्स के पार काम करते समय UTC सामान्यीकरण सहायक होता है।

और उन्नत उपयोग के मामले

Datetime बुनियादी पार्सिंग और गणित से आगे कई वर्कफ़्लोज़ में दिखता है। यहाँ कुछ पैटर्न हैं जिनसे आप अक्सर मिलेंगे।

Unix टाइमस्टैम्प्स

Unix टाइमस्टैम्प 1 जनवरी, 1970 (UTC) से सेकंड मापते हैं। ये सिस्टम प्रोग्रामिंग और API में व्यापक रूप से उपयोग होते हैं।

from datetime import datetime
dt = datetime.fromtimestamp(1700000000)
print(dt)संचालित द्वारा

मिलीसेकंड और माइक्रोसेकंड के लिए स्केलिंग चाहिए:

ts_ms = 1700000000000
dt_ms = datetime.fromtimestamp(ts_ms / 1000)

ts_us = 1700000000000000
dt_us = datetime.fromtimestamp(ts_us / 1_000_000)संचालित द्वारा

शेड्यूलिंग और टाइमर्स

schedule जैसी लाइब्रेरी यह निर्धारित करने के लिए datetime मानों पर निर्भर करती हैं कि कार्य कब चलने चाहिए। चाहे आप कुछ सेकंड में एक बार फ़ंक्शन ट्रिगर कर रहे हों या दिन में बाद में एक बार चलने वाला इवेंट शेड्यूल कर रहे हों, datetime उन तुलनाओं की बुनियाद देता है।

डेटा विश्लेषण पैटर्न

ग्रूपिंग और समय-आधारित विश्लेषण के लिए अक्सर datetime एट्रिब्यूट्स निकाले जाते हैं:

dt = datetime(2025, 3, 1, 14, 30)
print(dt.year)
print(dt.isocalendar())संचालित द्वारा

pandas में अवधि के अनुसार रिसैंपलिंग बेहद आम है:

import pandas as pd
df = pd.DataFrame({
    "value": [10, 12, 15],
    "timestamp": pd.to_datetime([
        "2025-03-01",
        "2025-03-02",
        "2025-03-08"
    ])
}).set_index("timestamp")

print(df.resample("W").sum())संचालित द्वारा

निष्कर्ष

datetime के बारे में अधिक जानने के लिए, कृपया हमारे कोर्स Working with Dates and Times in Python (लेखक: Max Shrom) और Jason Myers द्वारा Data Types for Data Science in Python का यह वीडियो देखें। 

आप हमारा Converting Strings to Dates as datetime Objects ट्यूटोरियल भी उपयोगी पाएँगे, यदि आपको स्ट्रिंग्स को बदलने में थोड़ी अतिरिक्त मदद चाहिए।