Python Language
दिनांक और समय

टिप्पणियों

एक टाइमज़ोन जागरूक डेटाइम ऑब्जेक्ट में एक स्ट्रिंग पार्स करना

जब किसी स्ट्रिंग को datetime ऑब्जेक्ट में पार्स कर रहा है, तो पायथन 3.2+ में %z प्रारूप के लिए समर्थन होता है।

UTC फॉर्म +HHMM -HHMM या -HHMM (खाली स्ट्रिंग यदि वस्तु भोली है) में ऑफसेट।

import datetime
dt = datetime.datetime.strptime("2016-04-15T08:27:18-0500", "%Y-%m-%dT%H:%M:%S%z")

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

import dateutil.parser
dt = dateutil.parser.parse("2016-04-15T08:27:18-0500")

dt चर अब निम्नलिखित मूल्य के साथ एक datetime ऑब्जेक्ट है:

datetime.datetime(2016, 4, 15, 8, 27, 18, tzinfo=tzoffset(None, -18000))

सरल तिथि अंकगणित

तिथियां अलगाव में मौजूद नहीं हैं। यह आम है कि आपको तारीखों के बीच समय की मात्रा का पता लगाना होगा या यह निर्धारित करना होगा कि तारीख कल क्या होगी। यह timedelta वस्तुओं का उपयोग करके पूरा किया जा सकता है

import datetime

today = datetime.date.today()
print('Today:', today)

yesterday = today - datetime.timedelta(days=1)
print('Yesterday:', yesterday)

tomorrow = today + datetime.timedelta(days=1)
print('Tomorrow:', tomorrow)

print('Time between tomorrow and yesterday:', tomorrow - yesterday)

इससे परिणाम समान होंगे:

Today: 2016-04-15
Yesterday: 2016-04-14
Tomorrow: 2016-04-16
Difference between tomorrow and yesterday: 2 days, 0:00:00

बुनियादी डेटाटाइम ऑब्जेक्ट उपयोग करते हैं

डेटाइम मॉड्यूल में तीन प्राथमिक प्रकार के ऑब्जेक्ट होते हैं - दिनांक, समय और डेटाइम।

import datetime

# Date object
today = datetime.date.today()
new_year = datetime.date(2017, 01, 01) #datetime.date(2017, 1, 1)

# Time object
noon = datetime.time(12, 0, 0) #datetime.time(12, 0)

# Current datetime
now = datetime.datetime.now()

# Datetime object
millenium_turn = datetime.datetime(2000, 1, 1, 0, 0, 0) #datetime.datetime(2000, 1, 1, 0, 0)

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

# subtraction of noon from today
noon-today
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.date'
However, it is straightforward to convert between types.

# Do this instead
print('Time since the millenium at midnight: ',
      datetime.datetime(today.year, today.month, today.day) - millenium_turn)

# Or this
print('Time since the millenium at noon: ',
      datetime.datetime.combine(today, noon) - millenium_turn)

तारीखों पर फेरबदल

कभी-कभी आप एक आरंभ तिथि से लेकर कुछ अंतिम तिथि तक की एक सीमा से अधिक चलना चाहते हैं। आप का उपयोग कर ऐसा कर सकते हैं datetime पुस्तकालय और timedelta वस्तु:

import datetime

# The size of each step in days
day_delta = datetime.timedelta(days=1)

start_date = datetime.date.today()
end_date = start_date + 7*day_delta

for i in range((end_date - start_date).days):
    print(start_date + i*day_delta)

जो पैदा करता है:

2016-07-21
2016-07-22
2016-07-23
2016-07-24
2016-07-25
2016-07-26
2016-07-27

टाइमजोन अवगत डेटाटाइम ऑब्जेक्ट में थोड़े समय क्षेत्र नाम के साथ एक स्ट्रिंग पार्स करना

dateutil -जागरूक टाइमस्टैम्प को पार्स करने पर पिछले उदाहरण के रूप में dateutil लाइब्रेरी का उपयोग करना, एक निर्दिष्ट "लघु" समय क्षेत्र के नाम के साथ टाइमस्टैम्प को पार्स करना भी संभव है।

थोड़े समय क्षेत्र के नाम या संक्षिप्त रूपों के साथ प्रारूपित तारीखों के लिए, जो आम तौर पर अस्पष्ट हैं (उदाहरण के लिए सीएसटी, जो केंद्रीय मानक समय, चीन मानक समय, क्यूबा मानक समय, आदि हो सकता है - अधिक यहां पाया जा सकता है ) या जरूरी नहीं कि मानक डेटाबेस में उपलब्ध हो , समय क्षेत्र के संक्षिप्त नाम और tzinfo ऑब्जेक्ट के बीच मानचित्रण को निर्दिष्ट करना आवश्यक है।

from dateutil import tz
from dateutil.parser import parse

ET = tz.gettz('US/Eastern')
CT = tz.gettz('US/Central')
MT = tz.gettz('US/Mountain')
PT = tz.gettz('US/Pacific')

us_tzinfos = {'CST': CT, 'CDT': CT,
              'EST': ET, 'EDT': ET,
              'MST': MT, 'MDT': MT,
              'PST': PT, 'PDT': PT}

dt_est = parse('2014-01-02 04:00:00 EST', tzinfos=us_tzinfos)
dt_pst = parse('2016-03-11 16:00:00 PST', tzinfos=us_tzinfos)

इसे चलाने के बाद:

dt_est
# datetime.datetime(2014, 1, 2, 4, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))
dt_pst
# datetime.datetime(2016, 3, 11, 16, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Pacific'))

यह ध्यान देने योग्य है कि यदि इस विधि के साथ pytz समय क्षेत्र का उपयोग किया pytz , तो यह ठीक से स्थानीयकृत नहीं होगा:

from dateutil.parser import parse
import pytz

EST = pytz.timezone('America/New_York')
dt = parse('2014-02-03 09:17:00 EST', tzinfos={'EST': EST})

यह बस pytz समय क्षेत्र को pytz जोड़ता है:

dt.tzinfo # Will be in Local Mean Time!
# <DstTzInfo 'America/New_York' LMT-1 day, 19:04:00 STD>

यदि इस विधि का उपयोग कर रहे हैं, तो आपको संभवतः पार्स करने के बाद डेटाइम के भोले भाग को फिर से localize चाहिए:

dt_fixed = dt.tzinfo.localize(dt.replace(tzinfo=None))
dt_fixed.tzinfo # Now it's EST.
# <DstTzInfo 'America/New_York' EST-1 day, 19:00:00 STD>)

टाइमजोन-जागरूक डेटाटाइम्स का निर्माण

डिफ़ॉल्ट रूप से सभी datetime ऑब्जेक्ट भोले होते हैं। उन्हें tzinfo -जागरूक बनाने के लिए, आपको एक tzinfo ऑब्जेक्ट संलग्न करना होगा, जो दिनांक और समय के फ़ंक्शन के रूप में UTC ऑफसेट और tzinfo संक्षिप्त नाम प्रदान करता है।

निश्चित ऑफसेट समय क्षेत्र

समय क्षेत्रों है कि कर रहे हैं एक यूटीसी से ऑफसेट तय अजगर 3.2+ में, के लिए, datetime मॉड्यूल प्रदान करता है timezone वर्ग, का एक ठोस कार्यान्वयन tzinfo है, जो एक लेता है timedelta और एक (वैकल्पिक) नाम पैरामीटर:

from datetime import datetime, timedelta, timezone
JST = timezone(timedelta(hours=+9))

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=JST)
print(dt)
# 2015-01-01 12:00:00+09:00

print(dt.tzname())
# UTC+09:00

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=timezone(timedelta(hours=9), 'JST'))
print(dt.tzname)
# 'JST'

3.2 से पहले पायथन संस्करणों के लिए, थर्ड पार्टी लाइब्रेरी का उपयोग करना आवश्यक है, जैसे कि dateutil । dateutil एक समतुल्य वर्ग प्रदान करता है, tzoffset , जो (संस्करण 2.5.3 के रूप में) dateutil.tz.tzoffset(tzname, offset) के रूप लेता है, जहाँ सेकंड में offset निर्दिष्ट किया जाता है:

from datetime import datetime, timedelta
from dateutil import tz

JST = tz.tzoffset('JST', 9 * 3600) # 3600 seconds per hour
dt = datetime(2015, 1, 1, 12, 0, tzinfo=JST)
print(dt)
# 2015-01-01 12:00:00+09:00
print(dt.tzname)
# 'JST'

दिन की बचत समय के साथ क्षेत्र

दिन के समय की बचत के समय वाले क्षेत्रों के लिए, पायथन मानक पुस्तकालय एक मानक वर्ग प्रदान नहीं करते हैं, इसलिए तीसरे पुस्तकालय पुस्तकालय का उपयोग करना आवश्यक है। pytz और dateutil समय क्षेत्र कक्षाएं प्रदान करने वाले लोकप्रिय पुस्तकालय हैं।

स्टैटिक टाइम ज़ोन के अलावा, dateutil टाइम ज़ोन क्लासेस प्रदान करता है जो डेलाइट बचत समय का उपयोग करते हैं ( tz मॉड्यूल के लिए प्रलेखन देखें)। आप उपयोग कर सकते हैं tz.gettz() एक समय क्षेत्र वस्तु है, जो तब के लिए सीधे पारित किया जा सकता प्राप्त करने के लिए विधि datetime निर्माता:

from datetime import datetime
from dateutil import tz
local = tz.gettz() # Local time
PT = tz.gettz('US/Pacific') # Pacific time

dt_l = datetime(2015, 1, 1, 12, tzinfo=local) # I am in EST
dt_pst = datetime(2015, 1, 1, 12, tzinfo=PT)
dt_pdt = datetime(2015, 7, 1, 12, tzinfo=PT) # DST is handled automatically
print(dt_l)
# 2015-01-01 12:00:00-05:00
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-07-01 12:00:00-07:00

चेतावनी : संस्करण 2.5.3 के रूप में, dateutil अस्पष्ट dateutil को सही तरीके से नहीं संभालता है, और बाद की तारीख में हमेशा डिफ़ॉल्ट होगा। एक dateutil समयक्षेत्र का प्रतिनिधित्व करने वाली वस्तु के निर्माण का कोई तरीका नहीं है, उदाहरण के लिए 2015-11-01 1:30 EDT-4 , क्योंकि यह एक दिन के बचत समय संक्रमण के दौरान है।

pytz का उपयोग करते समय सभी किनारे मामलों को ठीक से संभाला जाता है, लेकिन pytz समय क्षेत्र सीधे निर्माणकर्ता के माध्यम से समय क्षेत्र से जुड़ा नहीं होना चाहिए। इसके बजाय, समय क्षेत्र के localize विधि का उपयोग करके एक pytz समय क्षेत्र संलग्न किया जाना चाहिए:

from datetime import datetime, timedelta
import pytz

PT = pytz.timezone('US/Pacific')
dt_pst = PT.localize(datetime(2015, 1, 1, 12))
dt_pdt = PT.localize(datetime(2015, 11, 1, 0, 30))
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-11-01 00:30:00-07:00

इस बात से अवगत रहें कि यदि आप pytz अनजान समय क्षेत्र पर pytz अंकगणित करते हैं, तो आपको या तो यूटीसी में गणना करना होगा (यदि आप पूर्ण समय व्यतीत करना चाहते हैं), या आपको परिणाम पर normalize() कॉल करना होगा:

dt_new = dt_pdt + timedelta(hours=3) # This should be 2:30 AM PST
print(dt_new)
# 2015-11-01 03:30:00-07:00
dt_corrected = PT.normalize(dt_new)
print(dt_corrected)
# 2015-11-01 02:30:00-08:00

फ़ज़ी डेटाइम पार्सिंग (किसी टेक्स्ट से डेटाटाइम निकाल रहा है)

"फजी" मोड में dateutil पार्सर का उपयोग करके एक पाठ से एक तारीख निकालना संभव है, जहां स्ट्रिंग के घटकों को तिथि के भाग के रूप में मान्यता नहीं दी जाती है।

from dateutil.parser import parse

dt = parse("Today is January 1, 2047 at 8:21:00AM", fuzzy=True)
print(dt)

dt अब एक datetime ऑब्जेक्ट है और आपको datetime.datetime(2047, 1, 1, 8, 21) मुद्रित होता दिखाई देगा।

समय क्षेत्र के बीच स्विच करना

टाइम ज़ोन के बीच स्विच करने के लिए, आपको टाइम-ज़ोन से अवगत होने वाली डेटाटाइम ऑब्जेक्ट्स की आवश्यकता होती है।

from datetime import datetime
from dateutil import tz

utc = tz.tzutc()
local = tz.tzlocal()

utc_now = datetime.utcnow()
utc_now # Not timezone-aware.

utc_now = utc_now.replace(tzinfo=utc)
utc_now # Timezone-aware.

local_now = utc_now.astimezone(local)
local_now # Converted to local time.

न्यूनतम पुस्तकालयों के साथ एक अनियंत्रित आईएसओ 8601 टाइमस्टैम्प को पार्स करना

पायथन को आईएसओ 8601 टाइमस्टैम्प को पार्स करने के लिए केवल सीमित समर्थन है। के लिए strptime आप को पता है कि वास्तव में क्या प्रारूप उस में है की जरूरत है एक के stringification एक जटिलता के रूप में। datetime एक आईएसओ 8601 टाइमस्टैम्प, एक विभाजक और 6 अंकों अंश के रूप में अंतरिक्ष के साथ:

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 555555))
# '2016-07-22 09:25:59.555555'

लेकिन यदि अंश 0 है, तो कोई अंश आंशिक नहीं है

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 0))
# '2016-07-22 09:25:59'

लेकिन इन 2 रूपों में strptime लिए एक अलग प्रारूप की आवश्यकता strptime । इसके अलावा, strptime' does not support at all parsing minute timezones that have a : strptime' does not support at all parsing minute timezones that have a : strptime' does not support at all parsing minute timezones that have a : in it, thus 2016-07-22 09: 25: 59 + 0300 can be parsed, but the standard format 2016-07-22 09:25:59 +03: 00` नहीं कर सकते।

iso8601 नामक एक एकल-फ़ाइल लाइब्रेरी है जो आईएसओ 8601 टाइमस्टैम्प और केवल उन्हें पार्स करती है।

यह भिन्न और टाइमज़ोन का समर्थन करता है, और T विभाजक सभी एक ही कार्य के साथ:

import iso8601
iso8601.parse_date('2016-07-22 09:25:59')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22 09:25:59+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<FixedOffset '+03:00' ...>)
iso8601.parse_date('2016-07-22 09:25:59Z')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22T09:25:59.000111+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, 111, tzinfo=<FixedOffset '+03:00' ...>)

यदि कोई iso8601.parse_date सेट नहीं है, तो iso8601.parse_date UTC में चूक करता है। डिफ़ॉल्ट ज़ोन default_zone कीवर्ड तर्क के साथ बदला जा सकता है। विशेष रूप से, यदि यह डिफ़ॉल्ट के बजाय None , तो उन टाइमस्टैम्प्स जिनके पास स्पष्ट समयक्षेत्र नहीं है, उन्हें इसके बजाय भोले डेटासेट के रूप में लौटाया जाता है:

iso8601.parse_date('2016-07-22T09:25:59', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59)
iso8601.parse_date('2016-07-22T09:25:59Z', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)

टाइमस्टैम्प को डेटाइम में बदलना

datetime मॉड्यूल एक POSIX timestamp को ITC datetime ऑब्जेक्ट में बदल सकता है।

1 जनवरी, 1970 की आधी रात का युग है।

import time
from datetime import datetime
seconds_since_epoch=time.time()  #1469182681.709

utc_date=datetime.utcfromtimestamp(seconds_since_epoch) #datetime.datetime(2016, 7, 22, 10, 18, 1, 709000)

एक तारीख से महीनों को घटाकर सटीक

calendar मॉड्यूल का उपयोग करना

import calendar
from datetime import date

def monthdelta(date, delta):
    m, y = (date.month+delta) % 12, date.year + ((date.month)+delta-1) // 12
    if not m: m = 12
    d = min(date.day, calendar.monthrange(y, m)[1])
    return date.replace(day=d,month=m, year=y)

next_month = monthdelta(date.today(), 1) #datetime.date(2016, 10, 23)

dateutils मॉड्यूल का उपयोग करना

import datetime
import dateutil.relativedelta

d = datetime.datetime.strptime("2013-03-31", "%Y-%m-%d")
d2 = d - dateutil.relativedelta.relativedelta(months=1)  #datetime.datetime(2013, 2, 28, 0, 0)

कम्प्यूटिंग समय अंतर

समय के बीच अंतर की गणना करने के लिए timedelta मॉड्यूल काम आता है:

from datetime import datetime, timedelta
now = datetime.now()
then = datetime(2016, 5, 23)     # datetime.datetime(2016, 05, 23, 0, 0, 0)

नई datetime ऑब्जेक्ट बनाते समय समय निर्दिष्ट करना वैकल्पिक है

delta = now-then

delta प्रकार की timedelta

print(delta.days)
# 60
print(delta.seconds)
# 40826

N का दिन और उसके बाद n का दिन प्राप्त करने के लिए हम उपयोग कर सकते हैं:

n दिन की तारीख के बाद:

def get_n_days_after_date(date_format="%d %B %Y", add_days=120):

    date_n_days_after = datetime.datetime.now() + timedelta(days=add_days)
    return date_n_days_after.strftime(date_format)

n दिन की तारीख से पहले:

 def get_n_days_before_date(self, date_format="%d %B %Y", days_before=120):

        date_n_days_ago = datetime.datetime.now() - timedelta(days=days_before)
        return date_n_days_ago.strftime(date_format)

आईएसओ 8601 टाइमस्टैम्प प्राप्त करें

बिना समयक्षेत्र के, माइक्रोसेकंड के साथ

from datetime import datetime

datetime.now().isoformat()
# Out: '2016-07-31T23:08:20.886783'

समयक्षेत्र के साथ, माइक्रोसेकंड के साथ

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).isoformat()
# Out: '2016-07-31T23:09:43.535074-07:00'

समयक्षेत्र के साथ, बिना माइक्रोसेकंड के

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).replace(microsecond=0).isoformat()
# Out: '2016-07-31T23:10:30-07:00'

आईएसओ 8601 को आईएसओ 8601 प्रारूप के बारे में अधिक जानकारी के लिए देखें।