Python timedelta: Python में समयांतराल के साथ काम करना

कई वास्तविक-जीवन के डेटासेट में तिथियाँ और समय शामिल होते हैं, और डेटा साइंस में एक सामान्य क्रिया दो समय बिंदुओं के बीच का अंतर निकालना है।

तारीख और समय को मापने की इकाइयाँ (वर्ष, महीने, दिन, घंटे, मिनट, सेकंड) हमेशा काम करने में आसान नहीं होतीं, खासकर जब इन इकाइयों की लंबाई अनियमित हो।

हालाँकि, Python के timedelta डेटा टाइप, जो datetime मॉड्यूल का हिस्सा है, समयांतराल की गणना की जटिलताओं को संभाल लेता है।

आइए पहले बहुत संक्षेप में समझते हैं कि Python का timedelta क्या है, और फिर विस्तार से देखते हैं।

Python में तिथियों और समय के बारे में अधिक जानने के लिए, यह कोर्स देखें: Working With Dates and Time in Python.

संक्षिप्त उत्तर: Python का timedelta क्या है

datetime मॉड्यूल के दो सबसे महत्वपूर्ण और अक्सर उपयोग होने वाले डेटा टाइप timedelta और datetime हैं। जहाँ datetime ऑब्जेक्ट समय के किसी विशिष्ट बिंदु का प्रतिनिधित्व करते हैं (जैसे, 1 जनवरी 2024, सुबह 10:30 बजे), वहीं timedelta ऑब्जेक्ट दो बिंदुओं के बीच की अवधि या अंतर का प्रतिनिधित्व करते हैं। इसे ऐसे समझें जैसे "कब?" (datetime) और "कितनी देर?" (timedelta) पूछने का फर्क।

मान लें दो तिथियाँ हैं, जिन्हें हम दो datetime ऑब्जेक्ट से दर्शा सकते हैं। एक तारीख को दूसरी से घटाने पर एक timedelta ऑब्जेक्ट बनता है जो दोनों तारीखों के बीच के समयांतराल को दर्शाता है:

import datetime

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime(year=2024, month=5, day=27)
interval = second_date - first_date
print(interval)

147 days, 0:00:00

आउटपुट दिखाता है कि दोनों तारीखें ठीक 147 दिनों के अंतर पर हैं। अगले उदाहरण में, हम कोड चलने के समय और तिथि को datetime.datetime.now() कॉल करके उपयोग करेंगे:

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime.now()
interval = second_date - first_date

print(second_date)
print(interval)

2024-05-28 08:32:44.871646
148 days, 8:32:44.871646

अब timedelta ऑब्जेक्ट 2024 की शुरुआत और कोड चलने की तिथि-समय के बीच बीते हुए समय को दिखाता है।

हम इस लेख में Python के timedelta को और विस्तार से समझेंगे।

timedelta ऑब्जेक्ट बनाना

पिछले खंड में, हमने दो datetime ऑब्जेक्ट से एक timedelta ऑब्जेक्ट बनाया, लेकिन हम timedelta() कंस्ट्रक्टर कॉल करके सीधे भी समयांतराल बना सकते हैं:

interval = datetime.timedelta(days=10, seconds=3600)
print(interval)

10 days, 1:00:00

यह अंतराल दस दिन और एक घंटा लंबा है। timedelta इंस्टेंस बनाते समय हम अन्य समय इकाइयों का भी उपयोग कर सकते हैं:

interval = datetime.timedelta(weeks=1, days=3, hours=1)
print(interval)

10 days, 1:00:00

timedelta() कॉल करते समय निम्नलिखित किसी भी समय इकाई का उपयोग मान्य है:

• weeks
• days
• hours
• minutes
• seconds
• milliseconds
• microseconds

यह ट्यूटोरियल आगे इस पर गहराई से जाएगा कि timedelta ऑब्जेक्ट में समयांतराल कैसे संग्रहित होते हैं।

timedelta के साथ बुनियादी गणित

हम timedelta ऑब्जेक्ट के साथ गणितीय क्रियाएँ भी कर सकते हैं। नीचे दिए गए तीन datetime ऑब्जेक्ट्स पर विचार करें, जो Python 1.0, Python 2.0, और Python 3.0 की रिलीज़ तिथियों का प्रतिनिधित्व करते हैं। datetime ऑब्जेक्ट्स को घटाने पर एक timedelta ऑब्जेक्ट बनता है:

release_date_python_1 = datetime.datetime(year=1991, month=2, day=20)
release_date_python_2 = datetime.datetime(year=2000, month=10, day=16)
release_date_python_3 = datetime.datetime(year=2008, month=12, day=3)

​time_between_1_and_2 = release_date_python_2 - release_date_python_1
time_between_2_and_3 = release_date_python_3 - release_date_python_2

​print(time_between_1_and_2)
print(time_between_2_and_3)

3526 days, 0:00:00
2970 days, 0:00:00

आउटपुट Python 1.0 और 2.0 की रिलीज़ के बीच तथा Python 2.0 और 3.0 की रिलीज़ के बीच दिनों की संख्या दिखाता है। ये समयांतराल timedelta ऑब्जेक्ट हैं।

हम timedelta और datetime ऑब्जेक्ट्स के बीच जोड़ और घटाव भी कर सकते हैं। आइए release_date_python_3 में days=100 वाला एक timedelta जोड़ते हैं:

print(release_date_python_3 + datetime.timedelta(days=100))

2009-03-13 00:00:00

Python 3.0, 3 दिसंबर 2008 को जारी हुआ था। इस तारीख में सौ दिन जोड़ने पर हम 13 मार्च 2009 पर पहुँचते हैं।

हम सीधे timedelta ऑब्जेक्ट्स के साथ भी गणितीय क्रियाएँ कर सकते हैं:

print("Difference between gap 1 and gap 2")
print(time_between_1_and_2 - time_between_2_and_3)

print("Sum of gap 1 and gap 2")
print(time_between_1_and_2 + time_between_2_and_3)

Difference between gap 1 and gap 2
556 days, 0:00:00

Sum of gap 1 and gap 2
6496 days, 0:00:00

आउटपुट पुष्टि करता है कि timedelta ऑब्जेक्ट्स को घटाया और जोड़ा जा सकता है। गुणा और भाग भी संभव हैं:

print("Multiply time interval by 3:")
print(time_between_1_and_2 * 3)

print("Divide time interval by 3:")
print(time_between_1_and_2 / 3)

Multiply time interval by 3:
10578 days, 0:00:00

Divide time interval by 3:
1175 days, 8:00:00

हम timedelta ऑब्जेक्ट्स की तुलना भी कर सकते हैं:

print("Check if gap 1 is greater than gap 2")
print(time_between_1_and_2 > time_between_2_and_3)

True

आउटपुट पुष्टि करता है कि Python 1.0 और Python 2.0 की रिलीज़ के बीच का अंतराल, Python 2.0 और Python 3.0 के बीच के अंतराल से लंबा है।

मुख्य timedelta गुण और विधियाँ

एक timedelta ऑब्जेक्ट समयांतराल का प्रतिनिधित्व दिनों, सेकंड और माइक्रोसेकंड की संख्या को संग्रहीत करके करता है। ये तीन इकाइयाँ ही timedelta क्लास में एट्रिब्यूट्स के रूप में दर्शाई जाती हैं:

interval = datetime.timedelta(
    weeks=1,
    hours=10,
    minutes=22,
    milliseconds=1042,
)

print(f"{interval = }")
print(f"{interval.days = }")
print(f"{interval.seconds = }")
print(f"{interval.microseconds = }")

interval = datetime.timedelta(days=7, seconds=37321, microseconds=42000)
interval.days = 7
interval.seconds = 37321
interval.microseconds = 42000

भले ही timedelta() कॉल में weeks, hours, minutes, और milliseconds के आर्ग्युमेंट दिए गए हैं, कंस्ट्रक्टर इन इकाइयों को days, seconds, और microseconds में बदल देता है। print() कॉल्स में f-strings के साथ इक्वल साइन = शामिल है ताकि वेरिएबल का नाम और उसकी वैल्यू दोनों दिखें। आप f-strings के बारे में अधिक इस ट्यूटोरियल में सीख सकते हैं: f-string formatting in Python.

timedelta क्लास का एक और उपयोगी टूल total_seconds() मेथड है। यह मेथड पूरे समयांतराल को सेकंड में लौटाता है:

print("Total time interval in seconds:")
print(interval.total_seconds())

Total time interval in seconds:
642121.042

यह मान पूरे समयांतराल को सेकंड में दर्शाता है। यह .seconds के मान जैसा नहीं है, जो केवल इंटरवल के सेकंड घटक को दिखाता है और दिनों व माइक्रोसेकंड को नहीं जोड़ता।

हम .total_seconds() से लौटे हुए मान का उपयोग समयांतराल को किसी भी अन्य इकाई में बदलने के लिए कर सकते हैं:

print("Total time interval in days:")
print(interval.total_seconds() / 3600 / 24)

Total time interval in days:
7.431956504629629

आउटपुट दिनों में समयांतराल दिखाता है क्योंकि .total_seconds() से मिले मान को एक घंटे में सेकंडों की संख्या और एक दिन में घंटों की संख्या से भाग दिया गया है।

timedelta उदाहरण: वृद्धि की गणना

आइए एक उदाहरण देखें। Python किताबें बेचने वाली एक कंपनी का ऑनलाइन स्टोर सभी बिक्री लॉग करता है। एक ग्राहक का डेटा इस प्रकार है:

data = {
    "customer_id": 3542,
    "sales": [
        {"date": "2024-04-21T13:23:45", "price": 24.99, "quantity": 1},
        {"date": "2024-02-13T10:54:12", "price": 24.99, "quantity": 2},
        {"date": "2024-01-08T20:32:24", "price": 18.99, "quantity": 1},
    ],
}

हमें किसी ग्राहक के पहले और आखिरी ऑर्डर के बीच का समयांतराल निकालना है। सूची में मौजूद सभी बिक्री हमेशा कालानुक्रमिक क्रम में होती हैं।

पहला कदम है, इस नेस्टेड संरचना से तिथियाँ निकालना और उन्हें datetime ऑब्जेक्ट्स में बदलना। सौभाग्य से, टाइमस्टैम्प मानक ISO 8601 प्रारूप (YYYY-MM-DDTHH:MM:SS) में हैं, इसलिए हम सुविधाजनक fromisoformat() मेथड का उपयोग कर सकते हैं:

sales = data["sales"]
dates = []
for item in sales:
    date = datetime.datetime.fromisoformat(item["date"])
    dates.append(date)

print(dates)

[datetime.datetime(2024, 4, 21, 13, 23, 45), datetime.datetime(2024, 2, 13, 10, 54, 12), datetime.datetime(2024, 1, 8, 20, 32, 24)]

सूची dates में प्रत्येक ऑर्डर की तिथियों वाले datetime ऑब्जेक्ट्स हैं। अब हम पहले और आखिरी ऑर्डर के बीच का समयांतराल निकाल सकते हैं:

time_span = dates[0] - dates[-1]
print(time_span)
print(time_span.days)

103 days, 16:51:21
103

पहली और आखिरी तिथि के अंतर से एक timedelta ऑब्जेक्ट मिलता है। कोड time_span दिखाता है, जिसमें दिनों, घंटों, मिनटों और सेकंडों की संख्या होती है। हम केवल पूरे दिनों की संख्या दिखाने के लिए time_span.days भी प्रदर्शित करते हैं।

यदि आप स्ट्रिंग्स को datetime में बदलने के बारे में अधिक जानना चाहते हैं, तो यह ट्यूटोरियल देखें: Python String to Datetime.

timedelta का उपयोग करते समय त्वरित सुझाव

आइए कुछ बातों पर ध्यान दें जब आप Python के timedelta का उपयोग करें:

1. इकाइयों से जुड़ी गलतियों से बचने के लिए timedelta() कॉल करते समय कीवर्ड आर्ग्युमेंट्स का उपयोग करना बेहतर है:

interval = datetime.timedelta(weeks=1, days=3, hours=1, milliseconds=1354)

2. अलग-अलग समय क्षेत्रों की दो तिथियों के बीच समयांतराल निकालते समय, timedelta पहले तिथियों को UTC में बदलकर फिर अंतर निकालता है:

import zoneinfo

some_date = datetime.datetime.fromisoformat("2024-01-01T00:00:00")

some_date_lon = some_date.replace(tzinfo=zoneinfo.ZoneInfo("Europe/London"))
some_date_nyc = some_date.replace(tzinfo=zoneinfo.ZoneInfo("America/New_York"))

print(some_date_lon)
print(some_date_nyc)
print(some_date_nyc - some_date_lon)

2024-01-01 00:00:00+00:00
2024-01-01 00:00:00-05:00
5:00:00

some_date में दी गई तिथि नए साल की शुरुआत दिखाती है। यह एक naive datetime ऑब्जेक्ट है क्योंकि इसमें समय क्षेत्र की जानकारी नहीं है। जबकि some_date_lon और some_date_nyc aware datetime ऑब्जेक्ट हैं क्योंकि वे क्रमशः लंदन और न्यूयॉर्क में नए साल की शुरुआत का प्रतिनिधित्व करते हैं।

दोनों aware datetime ऑब्जेक्ट्स को घटाने से मिला timedelta पाँच घंटे का समयांतराल दिखाता है, जो UTC समय अंतर है।

3. डेライト सेविंग में होने वाले बदलावों को timedelta ध्यान में नहीं रखता:

nyc = zoneinfo.ZoneInfo("America/New_York")

first_time = datetime.datetime.strptime("2024-03-10 1:00am", "%Y-%m-%d %I:%M%p")
first_time = first_time.replace(tzinfo=nyc)

second_time = datetime.datetime.strptime("2024-03-10 3:00am", "%Y-%m-%d %I:%M%p")
second_time = second_time.replace(tzinfo=nyc)

time_difference = second_time - first_time
print("Time difference between the first and second time:")
print(time_difference)

print("Checking the DST status of the first and second time:")
print(f"{first_time.dst() = }")
print(f"{second_time.dst() = }")

Time difference between the first and second time:
2:00:00

Checking the DST status of the first and second time:
first_time.dst() = datetime.timedelta(0)
second_time.dst() = datetime.timedelta(seconds=3600)

ये दोनों समय 10 मार्च 2024 को न्यूयॉर्क में सुबह 1:00 बजे और 3:00 बजे का प्रतिनिधित्व करते हैं। उसी दिन 2:00 बजे डेライト सेविंग शुरू हुई और घड़ियाँ 3:00 बजे पर चली गईं। इन दो समयों के बीच के अंतर से मिला timedelta दो घंटे दिखाता है, जबकि डेライト सेविंग शुरू होने के कारण वास्तविक रूप से केवल एक घंटा बीता था।

यदि हमें बीते हुए वास्तविक समय की आवश्यकता हो, तो हम UTC में बदल सकते हैं:

first_time_utc = first_time.astimezone(zoneinfo.ZoneInfo("UTC"))
second_time_utc = second_time.astimezone(zoneinfo.ZoneInfo("UTC"))
time_difference_utc = second_time_utc - first_time_utc

print("Actual time difference between the first and second time:")
print(time_difference_utc)

Actual time difference between the first and second time:
1:00:00

घटाने से पहले UTC में बदलने पर दोनों datetime ऑब्जेक्ट्स के बीच वास्तविक समय मिलता है।

निष्कर्ष

Python की timedelta क्लास समयांतराल सँभालने के लिए सरल तरीक़े देती है, जिससे विभिन्न इकाइयों में समय के साथ काम करना आसान हो जाता है। हमने देखा कि timedelta ऑब्जेक्ट कैसे बनाए जाते हैं और उनके साथ जोड़, घटाव, गुणा, और भाग जैसी गणितीय क्रियाएँ कैसे की जाती हैं।

आप तिथियों और समय के साथ काम करने पर ये लेख भी पढ़ सकते हैं:

• Working with Dates and Times in Python Cheat Sheet
• Python String to DateTime: How to Convert Strings to DateTime Objects in Python
• Working with Dates and Times in Python