Python 3.7 - datetime

डेटाइम - मूल तिथि और समय प्रकार




python

डेटाइम - मूल तिथि और समय प्रकार

स्रोत कोड: Lib/datetime.py

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

दो प्रकार के दिनांक और समय ऑब्जेक्ट हैं: "भोले" और "जागरूक"।

एक जागरूक वस्तु को लागू एल्गोरिथम और राजनीतिक समय समायोजन, जैसे कि समय क्षेत्र और दिन के समय की बचत के समय की जानकारी के बारे में पर्याप्त जानकारी होती है, अन्य जागरूक वस्तुओं के सापेक्ष खुद को खोजने के लिए। एक जागरूक वस्तु का उपयोग उस विशिष्ट समय का प्रतिनिधित्व करने के लिए किया जाता है जो व्याख्या के लिए खुला नहीं है [1]

एक भोली वस्तु में अन्य तिथि / समय वस्तुओं के सापेक्ष स्वयं को खोजने के लिए पर्याप्त जानकारी नहीं होती है। क्या कोई भोली वस्तु कोऑर्डिनेटेड यूनिवर्सल टाइम (UTC), स्थानीय समय, या किसी अन्य टाइमज़ोन में समय विशुद्ध रूप से कार्यक्रम का प्रतिनिधित्व करती है, ठीक वैसे ही जैसे यह प्रोग्राम के ऊपर है कि क्या कोई विशेष संख्या मीटर, मील या मास का प्रतिनिधित्व करती है। वास्तविकता के कुछ पहलुओं को अनदेखा करने की कीमत पर Naive वस्तुओं को समझना और उनके साथ काम करना आसान है।

जागरूक वस्तुओं की आवश्यकता वाले अनुप्रयोगों के लिए, tzinfo और time ऑब्जेक्ट्स में वैकल्पिक समय क्षेत्र सूचना विशेषता, tzinfo , जो कि अमूर्त tzinfo वर्ग के एक उपवर्ग के उदाहरण के लिए सेट किया जा सकता है। ये tzinfo ऑब्जेक्ट्स UTC के समय, समय क्षेत्र के नाम, और क्या डेलाइट सेविंग टाइम प्रभावी है, के बारे में जानकारी कैप्चर करते हैं। ध्यान दें कि केवल एक ठोस tzinfo वर्ग, tzinfo वर्ग, tzinfo मॉड्यूल द्वारा आपूर्ति की जाती है। timezone वर्ग यूटीसी से निश्चित ऑफसेट के साथ सरल टाइमज़ोन का प्रतिनिधित्व कर सकता है, जैसे कि यूटीसी स्वयं या उत्तरी अमेरिकी ईएसटी और ईडीटी टाइमज़ोन। विस्तार के गहन स्तरों पर टाइमज़ोन का समर्थन करना एप्लिकेशन पर निर्भर है। दुनिया भर में समय समायोजन के नियम तर्कसंगत से अधिक राजनीतिक हैं, बार-बार बदलते हैं, और यूटीसी से अलग हर आवेदन के लिए कोई मानक उपयुक्त नहीं है।

datetime मॉड्यूल निम्नलिखित स्थिरांक का निर्यात करता है:

datetime.MINYEAR

किसी date या datetime ऑब्जेक्ट में दी गई सबसे छोटी वर्ष संख्या। MINYEAR 1

datetime.MAXYEAR

किसी date या datetime ऑब्जेक्ट में अनुमत सबसे बड़ी वर्ष संख्या। MAXYEAR 9999

यह भी देखें

Module calendar
सामान्य कैलेंडर संबंधी कार्य।
Module time
समय का उपयोग और रूपांतरण।

उपलब्ध प्रकार

class datetime.date

वर्तमान ग्रेगोरियन कैलेंडर को मानते हुए एक आदर्श भोली तारीख, और हमेशा प्रभाव में होगी। विशेषताएं: year , month और day

class datetime.time

एक आदर्श समय, किसी विशेष दिन से स्वतंत्र, यह मानते हुए कि हर दिन बिल्कुल 24 * 60 * 60 सेकंड है (यहां "लीप सेकंड" की कोई धारणा नहीं है)। विशेषताएं: hour , minute , second , microsecond , और tzinfo

class datetime.datetime

एक तिथि और एक समय का संयोजन। विशेषताएं: year , month , day , hour , minute , second , microsecond , और tzinfo

class datetime.timedelta

माइक्रोसेकंड रिज़ॉल्यूशन के लिए दो date , time या datetime उदाहरणों के बीच अंतर को व्यक्त करने वाली अवधि।

class datetime.tzinfo

समय क्षेत्र सूचना वस्तुओं के लिए एक सार आधार वर्ग। ये समय समायोजन (उदाहरण के लिए, समय क्षेत्र और / या दिन के उजाले की बचत समय के लिए खाते में) की एक अनुकूलन धारणा प्रदान करने के लिए datetime और time कक्षाओं द्वारा उपयोग किया जाता है।

class datetime.timezone

एक वर्ग जो UTC से निश्चित ऑफसेट के रूप में tzinfo अमूर्त आधार वर्ग को लागू करता है।

संस्करण 3.2 में नया।

इस प्रकार की वस्तुएँ अपरिवर्तनीय हैं।

date प्रकार की वस्तुएँ हमेशा भोली होती हैं।

प्रकार के time या datetime की एक वस्तु भोली या जागरूक हो सकती है। यदि d.tzinfo कोई None और d.tzinfo.utcoffset(d) None नहीं d.tzinfo है, तो एक d.tzinfo ऑब्जेक्ट d पता होता है। यदि d.tzinfo None , या यदि d.tzinfo None , लेकिन d.tzinfo.utcoffset(d) None लौटाता है, तो d भोली है। यदि t.tzinfo कोई None और t.tzinfo.utcoffset(None) None है, तो एक time ऑब्जेक्ट t पता है। अन्यथा, टी भोली है।

भोले और जागरूक के बीच का अंतर timedelta वस्तुओं पर लागू नहीं होता है।

उपवर्ग संबंध:

object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime

समयबद्ध वस्तुएं

एक timedelta वस्तु एक अवधि का प्रतिनिधित्व करती है, दो तिथियों या समय के बीच का अंतर।

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

सभी तर्क वैकल्पिक और डिफ़ॉल्ट 0 । तर्क पूर्णांक या फ़्लोट्स हो सकते हैं, और सकारात्मक या नकारात्मक हो सकते हैं।

केवल दिन , सेकंड और माइक्रोसेकंड आंतरिक रूप से संग्रहीत होते हैं। तर्क उन इकाइयों में परिवर्तित हो जाते हैं:

  • एक मिलीसेकंड को 1000 माइक्रोसेकंड में बदल दिया जाता है।
  • एक मिनट को 60 सेकंड में बदल दिया जाता है।
  • एक घंटे को 3600 सेकंड में बदल दिया जाता है।
  • एक सप्ताह को 7 दिनों में बदल दिया जाता है।

और दिन, सेकंड और माइक्रोसेकेंड तब सामान्यीकृत होते हैं ताकि प्रतिनिधित्व अद्वितीय हो, साथ

  • 0 <= microseconds < 1000000
  • 0 <= seconds < 3600*24 (एक दिन में सेकंड की संख्या)
  • -999999999 <= days <= 999999999

यदि कोई तर्क एक फ्लोट है और इसमें आंशिक माइक्रोसेकंड हैं, तो सभी तर्कों से बचे हुए आंशिक माइक्रोसेकंड को संयुक्त किया जाता है और उनकी राशि को राउंड-हाफ-टू-टू-टाईब्रेकर का उपयोग करके निकटतम माइक्रोसेकंड पर लगाया जाता है। यदि कोई तर्क एक फ्लोट नहीं है, तो रूपांतरण और सामान्यीकरण प्रक्रियाएं सटीक हैं (कोई जानकारी नहीं खो जाती है)।

यदि दिनों का सामान्यीकृत मान इंगित सीमा के बाहर है, तो OverflowError को उठाया जाता है।

ध्यान दें कि नकारात्मक मूल्यों का सामान्यीकरण पहली बार में आश्चर्यजनक हो सकता है। उदाहरण के लिए,

>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
(-1, 86399, 999999)

वर्ग की विशेषताएं हैं:

timedelta.min

सबसे नकारात्मक timedelta(-999999999) ऑब्जेक्ट, timedelta(-999999999)

timedelta.max

सबसे सकारात्मक timedelta वस्तु, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)

timedelta.resolution

गैर-बराबर timedelta ऑब्जेक्ट्स, timedelta(microseconds=1) बीच सबसे छोटा संभव अंतर।

ध्यान दें कि, सामान्यीकरण के कारण, -timedelta.min > -timedelta.min-timedelta.max एक -timedelta.max ऑब्जेक्ट के रूप में प्रतिनिधित्व करने योग्य नहीं है।

उदाहरण विशेषताएँ (केवल पढ़ने के लिए):

गुण मूल्य
days बीच -999999999 और 999999999 के बीच
seconds 0 और 86399 के बीच समावेशी
microseconds 0 और 999999 के बीच समावेशी

समर्थित संचालन:

ऑपरेशन परिणाम
t1 = t2 + t3 T2 और t3 का योग। बाद में t1 - t2 == t3 और t1 - t3 == t2 सत्य हैं। (1)
t1 = t2 - t3 टी 2 और टी 3 का अंतर। बाद में t1 == t2 - t3 और t2 == t1 + t3 सत्य हैं। (1) (6)
t1 = t2 * i or t1 = i * t2 डेल्टा एक पूर्णांक द्वारा गुणा किया जाता है। बाद में t1 // i == t2 सच है, बशर्ते i != 0
सामान्य तौर पर, t1 * i == t1 * (i-1) + t1 सत्य है। (1)
t1 = t2 * f or t1 = f * t2 डेल्टा एक फ्लोट से गुणा किया जाता है। परिणाम गोल-अर्ध-सम-विषम का उपयोग करते हुए समीपवर्ती कई समयावधि के लिए किया जाता है।
f = t2 / t3 T3 द्वारा t2 का विभाजन (3)। एक float ऑब्जेक्ट लौटाता है।
t1 = t2 / f or t1 = t2 / i एक फ्लोट या एक इंट द्वारा विभाजित डेल्टा। परिणाम गोल-अर्ध-सम-विषम का उपयोग करते हुए समीपवर्ती कई समयावधि के लिए किया जाता है।
t1 = t2 // i या t1 = t2 // t3 मंजिल की गणना की जाती है और शेष (यदि कोई हो) को फेंक दिया जाता है। दूसरे मामले में, एक पूर्णांक लौटाया जाता है। (3)
t1 = t2 % t3 शेष की गणना एक timedelta वस्तु के रूप में की जाती है। (3)
q, r = divmod(t1, t2) भागफल और शेष की गणना करता है: q = t1 // t2 (3) और r = t1 % t2 । q एक पूर्णांक है और r एक timedelta वस्तु है।
+t1 समान मूल्य के साथ एक timedelta वस्तु लौटाता है। (2)
-t1 समतुल्य समय के बराबर (- t1.days , - t1.seconds , - t1.microseconds ), और t1 * -1 तक। (1) (4)
abs(t) t.days >= 0 , और - to t t.days < 0 । (2)
str(t) [D day[s], ][H]H:MM:SS[.UUUUUU] के रूप में एक स्ट्रिंग लौटाता है, जहाँ D ऋणात्मक t लिए ऋणात्मक t । (5)
repr(t) समय-समय पर ऑब्जेक्ट की एक स्ट्रिंग प्रतिनिधित्व को एक विहित कॉल के रूप में विहित विशेषता मूल्यों के साथ लौटाता है।

टिप्पणियाँ:

  1. यह सटीक है, लेकिन अतिप्रवाह हो सकता है।
  2. यह सटीक है, और अतिप्रवाह नहीं हो सकता।
  3. 0 से डिवीजन ZeroDivisionError उठाता है।
  4. - समयसीमा वस्तु के रूप में timedelta प्रतिनिधित्व करने योग्य नहीं है।
  5. timedelta वस्तुओं का स्ट्रिंग प्रतिनिधित्व उनके आंतरिक प्रतिनिधित्व के समान सामान्यीकृत होता है। यह नकारात्मक समय के लिए कुछ असामान्य परिणाम की ओर जाता है। उदाहरण के लिए:

    >>> timedelta(hours=-5)
    datetime.timedelta(days=-1, seconds=68400)
    >>> print(_)
    -1 day, 19:00:00
    
  6. अभिव्यक्ति t2 - t3 हमेशा अभिव्यक्ति t2 + (-t3) बराबर होगी सिवाय जब t3 t2 + (-t3) बराबर हो; उस स्थिति में पूर्व एक परिणाम देगा जबकि बाद में अतिप्रवाह होगा।

timedelta ऑब्जेक्ट्स के ऊपर सूचीबद्ध संचालन के अलावा, date और datetime ऑब्जेक्ट्स (नीचे देखें) के साथ कुछ अतिरिक्त और घटाव का समर्थन करते हैं।

संस्करण 3.2 में परिवर्तित: किसी अन्य timedelta ऑब्जेक्ट द्वारा एक timedelta ऑब्जेक्ट के फ़्लोर डिवीज़न और ट्रू डिवीज़न को अब समर्थित किया जाता है, जैसा कि शेष संचालन और divmod() फ़ंक्शन हैं। एक float ऑब्जेक्ट द्वारा एक timedelta ऑब्जेक्ट के सच्चे विभाजन और गुणन का समर्थन किया जाता है।

timedelta ऑब्जेक्ट्स की तुलना timedelta ऑब्जेक्ट के साथ समर्थित है, जिसे छोटी टाइमडेल्टा माना जाता है। मिश्रित प्रकार की तुलनाओं को ऑब्जेक्ट एड्रेस द्वारा डिफ़ॉल्ट तुलना में वापस गिरने से रोकने के लिए, जब एक timedelta ऑब्जेक्ट की तुलना एक अलग प्रकार की वस्तु से की जाती है, तो TypeError को तब तक उठाया जाता है जब तक कि तुलना == या != । बाद के मामले क्रमशः False या True हैं।

timedelta ऑब्जेक्ट्स hashable (शब्दकोश कुंजी के रूप में प्रयोग करने योग्य), कुशल अचार का समर्थन करते हैं, और बूलियन संदर्भों में, एक timedelta ऑब्जेक्ट को सही माना जाता है अगर और केवल अगर यह timedelta(0) बराबर नहीं है।

उदाहरण के तरीके:

timedelta.total_seconds()

अवधि में निहित सेकंड की कुल संख्या लौटाएं। td / timedelta(seconds=1) बराबर।

ध्यान दें कि बहुत बड़े समय के अंतराल (अधिकांश प्लेटफार्मों पर 270 से अधिक वर्षों) के लिए यह विधि माइक्रोसेकंड सटीकता खो देगी।

संस्करण 3.2 में नया।

उदाहरण का उपयोग:

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)  # adds up to 365 days
>>> year.total_seconds()
31536000.0
>>> year == another_year
True
>>> ten_years = 10 * year
>>> ten_years, ten_years.days // 365
(datetime.timedelta(days=3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(days=3285), 9)
>>> three_years = nine_years // 3
>>> three_years, three_years.days // 365
(datetime.timedelta(days=1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

दिनांक ऑब्जेक्ट्स

एक date ऑब्जेक्ट एक आदर्श कैलेंडर में एक तारीख (वर्ष, महीना और दिन) का प्रतिनिधित्व करता है, वर्तमान ग्रेगोरियन कैलेंडर दोनों दिशाओं में अनिश्चित काल तक विस्तारित रहता है। 1 वर्ष का 1 जनवरी को दिन नंबर 1 कहा जाता है, वर्ष 1 के 2 जनवरी को दिन नंबर 2 कहा जाता है, और इसी तरह। यह Dershowitz और Reingold की पुस्तक कैलेंड्रिकल कैलकुलेशन में "प्रोलेप्टिक ग्रेगोरियन" कैलेंडर की परिभाषा से मेल खाती है, जहां यह सभी गणनाओं के लिए आधार कैलेंडर है। प्रोलेप्टिक ग्रेगोरियन ऑर्डिनल्स और कई अन्य कैलेंडर प्रणालियों के बीच रूपांतरण के लिए एल्गोरिदम के लिए पुस्तक देखें।

class datetime.date(year, month, day)

सभी तर्कों की आवश्यकता है। निम्न श्रेणियों में तर्क पूर्णांक हो सकते हैं:

  • MINYEAR <= year <= MAXYEAR
  • 1 <= month <= 12
  • 1 <= day <= number of days in the given month and year

यदि उन सीमाओं के बाहर एक तर्क दिया जाता है, तो ValueError को उठाया जाता है।

अन्य निर्माता, सभी वर्ग विधियाँ:

classmethod date.today()

वर्तमान स्थानीय दिनांक वापस करें। यह date.fromtimestamp(time.time()) बराबर है।

classmethod date.fromtimestamp(timestamp)

POSIX टाइमस्टैम्प के अनुरूप स्थानीय तिथि लौटाएं, जैसे कि time.time() द्वारा लौटाया गया है। यदि localtime() प्लेटफ़ॉर्म C localtime() फ़ंक्शन, और OSError localtime() विफलता द्वारा समर्थित मानों की श्रेणी से बाहर है, तो यह OverflowError को बढ़ा सकता है। यह सामान्य है कि 1970 से 2038 के बीच के वर्षों तक इसे सीमित रखा जाए। ध्यान दें कि नॉन-पॉसिक्स सिस्टम पर जो टाइमस्टैम्प की उनकी धारणा में लीप सेकंड शामिल करते हैं, लीप fromtimestamp() लीप सेकंड को नजरअंदाज कर दिया जाता है।

संस्करण 3.3 में बदला गया: यदि टाइमस्टैम्प प्लेटफ़ॉर्म C localtime() फ़ंक्शन द्वारा समर्थित मानों की श्रेणी से बाहर है, तो ValueError बजाय OverflowError उठाएं। localtime() विफलता पर ValueError बजाय OSError उठाएँ।

classmethod date.fromordinal(ordinal)

प्रोलेप्टिक ग्रेगोरियन ऑर्डिनल के लिए उसी तारीख को लौटाएं, जहां 1 जनवरी को 1 साल का ऑर्डिनल होता है। जब तक 1 <= ordinal <= date.max.toordinal() । किसी भी तारीख d के लिए , date.fromordinal(d.toordinal()) == d

classmethod date.fromisoformat(date_string)

date.isoformat() द्वारा उत्सर्जित प्रारूप में date_string के अनुरूप date लौटाएं। विशेष रूप से, यह फ़ंक्शन प्रारूप में तार का समर्थन करता है YYYY-MM-DD

सावधान

यह आईएसओ 8601 स्ट्रिंग्स को मनमाने ढंग से पार्स करने का समर्थन नहीं करता है - यह केवल date.isoformat() के उलटा ऑपरेशन के रूप में करना है date.isoformat()

संस्करण 3.7 में नया।

वर्ग विशेषताएं:

date.min

जल्द से जल्द प्रतिनिधित्व योग्य तारीख, date(MINYEAR, 1, 1)

date.max

नवीनतम प्रतिनिधित्व योग्य दिनांक, date(MAXYEAR, 12, 31)

date.resolution

गैर-बराबर दिनांक ऑब्जेक्ट्स, timedelta(days=1) बीच सबसे छोटा संभव अंतर।

उदाहरण विशेषताएँ (केवल पढ़ने के लिए):

date.year

MINYEAR और MAXYEAR बीच समावेशी।

date.month

1 से 12 के बीच समावेशी।

date.day

दिए गए वर्ष के दिए गए महीने में 1 और दिनों के बीच।

समर्थित संचालन:

ऑपरेशन परिणाम
date2 = date1 + timedelta तारीख 2 को समय 1 से हटा दिया गया है। (1)
date2 = date1 - timedelta तारीख 2 की गणना करता है जैसे कि date2 + timedelta == date1 । (2)
timedelta = date1 - date2 (3)
date1 < date2 तारीख 1 को तारीख 2 से कम माना जाता है जब तारीख 1 तारीख से पहले होती है। (4)

टिप्पणियाँ:

  1. date2 को समय में आगे ले जाया जाता है अगर timedelta.days > 0 , या backed अगर timedelta.days < 0 । बाद की date2 - date1 == timedelta.daysdate2 - date1 == timedelta.daystimedelta.seconds और timedelta.microseconds की अनदेखी की जाती है। date2.year उठाया जाता है अगर date2.year से MINYEAR या MINYEAR से बड़ा होगा।
  2. timedelta.seconds और timedelta.microseconds की अनदेखी की जाती है।
  3. यह सटीक है, और अतिप्रवाह नहीं हो सकता। timedelta.seconds और timedelta.microseconds 0 हैं, और date2 + timedelta == date1 के बाद।
  4. दूसरे शब्दों में, date1 < date2 if और only if date1.toordinal() < date2.toordinal() । यदि अन्य तुलना भी date ऑब्जेक्ट नहीं है, तो तारीख की तुलना TypeError उठाती है। हालाँकि, NotImplemented को इसके बजाय लौटाया जाता है यदि अन्य तुलना में समय- timetuple() विशेषता है। यह हुक अन्य प्रकार की तारीख वस्तुओं को मिश्रित-प्रकार की तुलना को लागू करने का मौका देता है। यदि नहीं, तो जब किसी date वस्तु की तुलना किसी भिन्न प्रकार की वस्तु से की जाती है, तो TypeError को तब तक उठाया जाता है जब तक कि तुलना == या != । बाद के मामले क्रमशः False या True हैं।

तिथियों का उपयोग शब्दकोश कीज के रूप में किया जा सकता है। बूलियन संदर्भों में, सभी date ऑब्जेक्ट को सत्य माना जाता है।

उदाहरण के तरीके:

date.replace(year=self.year, month=self.month, day=self.day)

एक ही मान के साथ एक तारीख लौटाएं, उन मापदंडों को छोड़कर जो भी कीवर्ड तर्क द्वारा नए मान निर्दिष्ट किए गए हैं। उदाहरण के लिए, यदि d == date(2002, 12, 31) , तो d.replace(day=26) == date(2002, 12, 26)

date.timetuple()

एक time.struct_time जैसे कि time.localtime() द्वारा लौटाया गया। घंटे, मिनट और सेकंड 0 हैं, और DST ध्वज -1 है। d.timetuple() time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1)) yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 , जहां yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 वर्तमान वर्ष के भीतर दिन की संख्या 1 जनवरी से 1 के साथ शुरू हो रही है।

date.toordinal()

तारीख के प्रोलेप्टिक ग्रेगोरियन ऑर्डिनल को लौटाएं, जहां 1 जनवरी को 1 वर्ष का date.fromordinal(d.toordinal()) == d होता है। किसी भी date ऑब्जेक्ट के लिए, date.fromordinal(d.toordinal()) == d

date.weekday()

सप्ताह के दिन को पूर्णांक के रूप में लौटाएं, जहां सोमवार 0 और रविवार है। उदाहरण के लिए, date(2002, 12, 4).weekday() == 2 , एक बुधवार। यह भी देखें isoweekday()

date.isoweekday()

सप्ताह के दिन को पूर्णांक के रूप में लौटाएं, जहां सोमवार 1 और रविवार है। उदाहरण के लिए, date(2002, 12, 4).isoweekday() == 3 , एक बुधवार। weekday() , isocalendar() भी देखें।

date.isocalendar()

3-टपल लौटें, (आईएसओ वर्ष, आईएसओ सप्ताह संख्या, आईएसओ कार्यदिवस)।

आईएसओ कैलेंडर ग्रेगोरियन कैलेंडर का व्यापक रूप से उपयोग किया जाने वाला संस्करण है। अच्छी व्याख्या के लिए https://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htm देखें।

आईएसओ वर्ष में 52 या 53 पूर्ण सप्ताह होते हैं, और जहां एक सप्ताह सोमवार को शुरू होता है और रविवार को समाप्त होता है। एक आईएसओ वर्ष का पहला सप्ताह गुरुवार को युक्त वर्ष का पहला (ग्रेगोरियन) कैलेंडर सप्ताह है। इसे सप्ताह नंबर 1 कहा जाता है, और उस गुरुवार का आईएसओ वर्ष इसके ग्रेगोरियन वर्ष के समान है।

उदाहरण के लिए, 2004 गुरुवार से शुरू होता है, इसलिए आईएसओ वर्ष 2004 का पहला सप्ताह सोमवार, 29 दिसंबर 2003 से शुरू होता है और रविवार 4 जनवरी 2004 को समाप्त होता है, इसलिए यह date(2003, 12, 29).isocalendar() == (2004, 1, 1) और date(2004, 1, 4).isocalendar() == (2004, 1, 7)

date.isoformat()

आईएसओ 8601 प्रारूप में तारीख का प्रतिनिधित्व करते हुए एक स्ट्रिंग लौटें, 'YYYY-MM-DD'। उदाहरण के लिए, date(2002, 12, 4).isoformat() == '2002-12-04'

date.__str__()

दिनांक d के लिए , str(d) d.isoformat() बराबर है।

date.ctime()

दिनांक का प्रतिनिधित्व करने वाली स्ट्रिंग लौटें, उदाहरण के लिए date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'd.ctime() , time.ctime(time.mktime(d.timetuple())) प्लेटफॉर्म पर है, जहां देशी C ctime() फंक्शन (जो time.ctime() करता है, लेकिन जो date.ctime() करता है date.ctime() नहीं आह्वान) सी मानक के अनुरूप है।

date.strftime(format)

स्पष्ट प्रारूप स्ट्रिंग द्वारा नियंत्रित दिनांक का प्रतिनिधित्व करने वाला स्ट्रिंग लौटाएं। घंटे, मिनट या सेकंड का संदर्भ स्वरूप कोड 0 मान देखेंगे। फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें

date.__format__(format)

date.strftime() रूप में भी। date.strftime() । यह स्वरूपित स्ट्रिंग str.format() में date ऑब्जेक्ट के लिए एक प्रारूप स्ट्रिंग और जब str.format() का उपयोग करना संभव बनाता है। फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें

किसी घटना के दिन गिनने का उदाहरण:

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2007, 12, 5)
>>> today == date.fromtimestamp(time.time())
True
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
...     my_birthday = my_birthday.replace(year=today.year + 1)
>>> my_birthday
datetime.date(2008, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
202

date साथ काम करने का उदाहरण:

>>> from datetime import date
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
>>> d
datetime.date(2002, 3, 11)
>>> t = d.timetuple()
>>> for i in t:     
...     print(i)
2002                # year
3                   # month
11                  # day
0
0
0
0                   # weekday (0 = Monday)
70                  # 70th day in the year
-1
>>> ic = d.isocalendar()
>>> for i in ic:    
...     print(i)
2002                # ISO year
11                  # ISO week number
1                   # ISO day number ( 1 = Monday )
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

डेटाइम ऑब्जेक्ट्स

datetime ऑब्जेक्ट एक एकल ऑब्जेक्ट है जिसमें date ऑब्जेक्ट और time ऑब्जेक्ट से सभी जानकारी होती है। date ऑब्जेक्ट की तरह, datetime दोनों ही दिशाओं में विस्तारित वर्तमान ग्रेगोरियन कैलेंडर को मानता है; एक समय की वस्तु की तरह, datetime मानता है कि हर दिन वास्तव में 3600 * 24 सेकंड हैं।

निर्माता:

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

वर्ष, महीने और दिन तर्क की आवश्यकता है। tzinfo None हो सकता है, या tzinfo उपवर्ग का एक उदाहरण हो सकता है। शेष तर्क पूर्णांक हो सकते हैं, निम्न श्रेणी में:

  • MINYEAR <= year <= MAXYEAR ,
  • 1 <= month <= 12 ,
  • 1 <= day <= number of days in the given month and year ,
  • 0 <= hour < 24 ,
  • 0 <= minute < 60 ,
  • 0 <= second < 60 ,
  • 0 <= microsecond < 1000000 ,
  • fold in [0, 1]

यदि उन सीमाओं के बाहर एक तर्क दिया जाता है, तो ValueError को उठाया जाता है।

संस्करण 3.6 में नया: fold तर्क जोड़ा गया।

अन्य निर्माता, सभी वर्ग विधियाँ:

classmethod datetime.today()

tzinfo None साथ, वर्तमान स्थानीय tzinfo । यह datetime.fromtimestamp(time.time()) बराबर है। now() भी देखें now() , fromtimestamp()

classmethod datetime.now(tz=None)

वर्तमान स्थानीय दिनांक और समय वापस करें। यदि वैकल्पिक तर्क tz None या निर्दिष्ट नहीं है, तो यह today() की तरह today() , लेकिन, यदि संभव हो, तो अधिक सटीक आपूर्ति करता है जो कि time.time() टाइमस्टैम्प से गुजरने से प्राप्त किया जा सकता है (उदाहरण के लिए, यह आपूर्ति करने वाले प्लेटफार्मों पर संभव हो सकता है सी gettimeofday() फ़ंक्शन)।

यदि tz कोई None , तो यह tzinfo उपवर्ग का एक उदाहरण होना चाहिए, और वर्तमान दिनांक और समय tz के समय क्षेत्र में परिवर्तित हो जाते हैं। इस स्थिति में परिणाम tz.fromutc(datetime.utcnow().replace(tzinfo=tz)) बराबर है। today() , utcnow() भी देखें।

classmethod datetime.utcnow()

वर्तमान UTC दिनांक और समय, tzinfo None साथ tzinfo । यह now() जैसा now() , लेकिन वर्तमान UTC दिनांक और समय, एक भोली datetime ऑब्जेक्ट के रूप में देता है। एक जागरूक वर्तमान UTC डेटाटाइम को datetime.now(timezone.utc) कॉल करके प्राप्त किया जा सकता है। now() भी देखें now()

classmethod datetime.fromtimestamp(timestamp, tz=None)

POSIX टाइमस्टैम्प के अनुरूप स्थानीय तिथि और समय लौटाएं, जैसे कि time.time() द्वारा लौटाया जाता है। यदि वैकल्पिक तर्क tz None या निर्दिष्ट नहीं है, तो टाइमस्टैम्प को प्लेटफ़ॉर्म की स्थानीय तिथि और समय में बदल दिया जाता है, और लौटी हुई datetime वस्तु भोली होती है।

यदि tz कोई None , तो यह tzinfo उपवर्ग का एक उदाहरण होना चाहिए, और टाइमस्टैम्प को tz के समय क्षेत्र में बदल दिया जाता है। इस मामले में परिणाम tz.fromutc(datetime.utcfromtimestamp(timestamp).replace(tzinfo=tz)) बराबर है।

fromtimestamp() OverflowError को बढ़ा सकता है, यदि टाइमस्टैम्प प्लेटफ़ॉर्म C localtime() या gmtime() फ़ंक्शंस द्वारा समर्थित मानों की श्रेणी से बाहर है, और OSError ऑन localtime() या gmtime() विफलता। 1970 में 2038 के माध्यम से इसे वर्षों तक प्रतिबंधित किया जाना आम है। ध्यान दें कि गैर-पॉसिक्स सिस्टम पर जो टाइमस्टैम्प की धारणा में लीप सेकंड को शामिल करते हैं, fromtimestamp() द्वारा लीप सेकंड को अनदेखा किया जाता है, और फिर दो टाइमस्टैम्प को अलग करना संभव है। समान datetime ऑब्जेक्ट्स को प्राप्त करने वाले दूसरे द्वारा। utcfromtimestamp() भी देखें।

संस्करण 3.3 में परिवर्तित किया गया: यदि टाइमस्टैम्प प्लेटफ़ॉर्म C localtime() या gmtime() फ़ंक्शन द्वारा समर्थित मानों की श्रेणी से बाहर है, तो ValueError बजाय OverflowError उठाएं। localtime() या gmtime() विफलता पर ValueError बजाय OSError उठाएँ।

संस्करण 3.6 में परिवर्तित: fromtimestamp() 1 से 1 fold साथ उदाहरणों को वापस कर सकता है।

classmethod datetime.utcfromtimestamp(timestamp)

POSIX टाइमस्टैम्प के अनुरूप UTC tzinfo , जिसमें tzinfo None । यदि gmtime() प्लेटफ़ॉर्म C gmtime() फ़ंक्शन, और OSError ऑन gmtime() विफलता द्वारा समर्थित मानों की श्रेणी से बाहर है, तो यह OverflowError को बढ़ा सकता है। 1970 में 2038 तक इसे सीमित रखना आम बात है।

एक जागरूक fromtimestamp() ऑब्जेक्ट प्राप्त करने के लिए, fromtimestamp() कॉल करें:

datetime.fromtimestamp(timestamp, timezone.utc)

POSIX आज्ञाकारी प्लेटफार्मों पर, यह निम्नलिखित अभिव्यक्ति के बराबर है:

datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

बाद के फार्मूले को छोड़कर हमेशा पूर्ण वर्ष की सीमा का समर्थन करता है: MINYEAR और MAXYEAR बीच समावेशी।

संस्करण 3.3 में बदला गया: टाइमस्टैम्प यदि प्लेटफ़ॉर्म C gmtime() फ़ंक्शन द्वारा समर्थित मानों की श्रेणी से बाहर है, तो ValueError बजाय OverflowError उठाएं। gmtime() विफलता पर ValueError बजाय OSError उठाएँ।

classmethod datetime.fromordinal(ordinal)

प्रोलेप्टिक ग्रेगोरियन ऑर्डिनल के अनुरूप डेटाइम को वापस लौटाएं, जहां 1 जनवरी को 1 वर्ष का ऑर्डिनल होता है। ValueRrror तब तक उठाया जाता है जब तक कि 1 <= ordinal <= datetime.max.toordinal() । परिणाम का घंटा, मिनट, दूसरा और माइक्रोसेकंड सभी 0 हैं, और tzinfo None

classmethod datetime.combine(date, time, tzinfo=self.tzinfo)

एक नया datetime ऑब्जेक्ट लौटाएँ, जिसका दिनांक घटक दिए गए date ऑब्जेक्ट के बराबर है, और जिसका समय घटक दिए गए time ऑब्जेक्ट के बराबर है। यदि tzinfo तर्क प्रदान किया जाता है, तो इसका मान परिणाम के tzinfo विशेषता को सेट करने के लिए उपयोग किया जाता है, अन्यथा समय तर्क के tzinfo विशेषता का उपयोग किया जाता है।

किसी भी d == datetime.combine(d.date(), d.time(), d.tzinfo) ऑब्जेक्ट के लिए d , d == datetime.combine(d.date(), d.time(), d.tzinfo) । यदि दिनांक एक tzinfo ऑब्जेक्ट है, तो इसके समय घटकों और tzinfo विशेषताओं को अनदेखा किया जाता है।

संस्करण 3.6 में परिवर्तित: tzinfo तर्क जोड़ा गया।

classmethod datetime.fromisoformat(date_string)

datetime date.isoformat() और datetime.isoformat() द्वारा उत्सर्जित स्वरूपों में से एक में डेट_string के समान डेटाइम लौटाएं । विशेष रूप से, यह फ़ंक्शन प्रारूप (s) YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]] , जहां * किसी भी एक चरित्र का मिलान कर सकता है।

सावधान

यह मनमाने ढंग से आईएसओ 8601 स्ट्रिंग्स को पार्स करने का समर्थन नहीं करता है - यह केवल datetime.isoformat() के उलटा संचालन के रूप में करना है।

संस्करण 3.7 में नया।

classmethod datetime.strptime(date_string, format)

दिनांक_string , प्रारूप के अनुसार पार्स किए गए के समान डेटाइम लौटाएं । यह datetime(*(time.strptime(date_string, format)[0:6])) बराबर है। Value_rror तब उठाया जाता है यदि date_string और फॉर्मेट को time.strptime() द्वारा पार्स नहीं किया जा सकता है या यदि यह एक मान लौटाता है जो टाइम ट्यूपल नहीं है। फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें

वर्ग विशेषताएं:

datetime.min

जल्द से जल्द प्रतिनिधित्व योग्य datetime(MINYEAR, 1, 1, tzinfo=None)

datetime.max

नवीनतम प्रतिनिधित्व योग्य datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)

datetime.resolution

गैर-समान datetime ऑब्जेक्ट, timedelta(microseconds=1) बीच सबसे छोटा संभव अंतर।

उदाहरण विशेषताएँ (केवल पढ़ने के लिए):

datetime.year

MINYEAR और MAXYEAR बीच समावेशी।

datetime.month

1 से 12 के बीच समावेशी।

datetime.day

दिए गए वर्ष के दिए गए महीने में 1 और दिनों के बीच।

datetime.hour

range(24)

datetime.minute

range(60)

datetime.second

range(60)

datetime.microsecond

range(1000000)

datetime.tzinfo

ऑब्जेक्ट tzinfo तर्क के रूप में डेटाटाइम निर्माता के पास गया, या None तो कोई भी पारित नहीं हुआ।

datetime.fold

[0, 1] । बार-बार अंतराल के दौरान दीवार के समय को भंग करने के लिए उपयोग किया जाता है। (बार-बार अंतराल तब होता है जब घड़ियों को दिन के समय की बचत के अंत में वापस लुढ़काया जाता है या जब राजनीतिक कारणों से वर्तमान क्षेत्र के लिए यूटीसी ऑफसेट कम हो जाता है।) मान 0 (1) दो क्षणों के पहले (बाद में) का प्रतिनिधित्व करता है। एक ही दीवार समय प्रतिनिधित्व।

संस्करण 3.6 में नया।

समर्थित संचालन:

ऑपरेशन परिणाम
datetime2 = datetime1 + timedelta (1)
datetime2 = datetime1 - timedelta (2)
timedelta = datetime1 - datetime2 (3)
datetime1 < datetime2 डेटाइम की तुलना datetime से करता है। (4)
  1. tzinfo की एक अवधि है, समय में आगे बढ़ रहा है अगर tzinfo > 0, या पिछड़ा अगर tzinfo <0. परिणाम इनपुट tzinfo रूप में एक ही tzinfo विशेषता है, और datetime2 - datetime1 == समय के बाद । OverflowError को उठाया जाता है, यदि datetime2.year MINYEAR से MINYEAR या MINYEAR से बड़ा होगा। ध्यान दें कि कोई समय क्षेत्र समायोजन नहीं किया जाता है, भले ही इनपुट एक जागरूक वस्तु हो।
  2. डेटाइम 2 की गणना करता है जैसे कि डेटटाइम 2 + टाइमडेल्टा == डेटाइम 1। इसके अतिरिक्त, परिणाम में इनपुट tzinfo के समान ही tzinfo विशेषता है, और इनपुट जागरूक होने पर भी कोई समय क्षेत्र समायोजन नहीं किया जाता है।
  3. डेटाइम से डेटाटाइम का घटाव केवल तभी परिभाषित किया जाता है जब दोनों ऑपरेशन्स भोले हों, या दोनों जागरूक हों। यदि एक जागरूक है और दूसरा अनुभवहीन है, तो TypeError को उठाया जाता है।

    यदि दोनों भोले हैं, या दोनों जागरूक हैं और एक ही tzinfo विशेषता है, tzinfo विशेषताओं को अनदेखा किया जाता है, और परिणाम एक timedelta ऑब्जेक्ट t है जैसे कि datetime2 + t == datetime1 । इस मामले में कोई समय क्षेत्र समायोजन नहीं किया जाता है।

    यदि दोनों जागरूक हैं और अलग-अलग tzinfo विशेषताएँ हैं, तो ab कार्य करता है जैसे कि a और b को पहले भोले UTC tzinfo परिवर्तित किया गया था। परिणाम है (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset()) इसके अलावा कि कार्यान्वयन कभी भी बंद नहीं होता।

  4. जब समय में डेटाटाइम 1 से पहले होता है, तो डेटाटाइम 1 को डेटटाइम 2 से कम माना जाता है।

    यदि एक तुलना भोली है और दूसरा जागरूक है, तो ऑर्डर की तुलना का प्रयास करने पर TypeError को उठाया जाता है। समानता तुलना के लिए, भोले उदाहरण कभी भी जागरूक उदाहरणों के बराबर नहीं होते हैं।

    यदि दोनों तुलनाएं अवगत हैं, और एक ही tzinfo विशेषता है, तो सामान्य tzinfo विशेषता को अनदेखा किया जाता है और आधार tzinfo की तुलना की जाती है। यदि दोनों तुलनाओं के बारे में पता है और अलग-अलग tzinfo विशेषताएँ हैं, तो तुलनाओं को पहले उनके UTC ऑफ़सेट ( self.utcoffset() से प्राप्त self.utcoffset() को घटाकर समायोजित किया जाता है।

    संस्करण 3.3 में बदला: भोले और जागरूक datetime उदाहरणों के बीच समानता की तुलना TypeError नहीं उठाती है।

    ध्यान दें

    ऑब्जेक्ट पतों की तुलना करने की डिफ़ॉल्ट स्कीम पर वापस गिरने से तुलना को रोकने के लिए, यदि अन्य तुलना भी एक डेटाइम ऑब्जेक्ट नहीं है, तो आम तौर पर डेटाइम तुलना टाइपऑयर को बढ़ाती है। हालाँकि, NotImplemented को इसके बजाय लौटाया जाता है यदि अन्य तुलना में समय- timetuple() विशेषता है। यह हुक अन्य प्रकार की तारीख वस्तुओं को मिश्रित-प्रकार की तुलना को लागू करने का मौका देता है। यदि नहीं, तो जब एक datetime ऑब्जेक्ट की तुलना किसी भिन्न प्रकार की वस्तु से की जाती है, तो TypeError को तब तक उठाया जाता है जब तक कि तुलना == या != । बाद के मामले क्रमशः False या True हैं।

शब्दकोश कुंजी के रूप में datetime वस्तुओं का उपयोग किया जा सकता है। बूलियन संदर्भों में, सभी datetime वस्तुओं को सत्य माना जाता है।

उदाहरण के तरीके:

datetime.date()

उसी वर्ष, महीने और दिन के साथ वापसी date वस्तु।

datetime.time()

एक ही घंटे, मिनट, दूसरा, माइक्रोसेकंड और गुना के साथ time वस्तु लौटें। tzinfo None । विधि timetz() भी देखें।

संस्करण 3.6 में बदला गया: गुना मान को लौटाए गए time ऑब्जेक्ट में कॉपी किया जाता है।

datetime.timetz()

एक ही घंटे, मिनट, दूसरे, माइक्रोसेकंड, गुना और tzinfo विशेषताओं के साथ time वस्तु लौटाएं। विधि time भी देखें।

संस्करण 3.6 में बदला गया: गुना मान को लौटाए गए time ऑब्जेक्ट में कॉपी किया जाता है।

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)

समान विशेषताओं के साथ एक डेटाइम लौटें, उन विशेषताओं को छोड़कर जो भी कीवर्ड तर्क द्वारा नए मान निर्दिष्ट किए गए हैं। ध्यान दें कि tzinfo=None को डेट और टाइम डेटा के रूपांतरण के साथ एक जागरूक tzinfo=None से एक भोली tzinfo=None बनाने के लिए निर्दिष्ट tzinfo=None जा सकता है।

संस्करण 3.6 में नया: fold तर्क जोड़ा गया।

datetime.astimezone(tz=None)

नए tzinfo विशेषता tz के साथ एक tzinfo ऑब्जेक्ट tzinfo , दिनांक और समय डेटा को समायोजित करें ताकि परिणाम स्वयं के रूप में एक ही UTC समय हो, लेकिन tz के स्थानीय समय में।

यदि प्रदान किया जाता है, तो tz को एक tzinfo उपवर्ग का एक उदाहरण होना चाहिए, और इसके utcoffset() और dst() विधियों में से None नहीं लौटना चाहिए। यदि स्वयं अनुभवहीन है, तो सिस्टम टाइमज़ोन में समय का प्रतिनिधित्व करना निर्धारित है।

यदि तर्कों के बिना कहा जाता है (या tz=None ) तो स्थानीय समयक्षेत्र को लक्ष्य समयक्षेत्र के लिए मान लिया जाता है। परिवर्तित .tzinfo उदाहरण की .tzinfo विशेषता ज़ोन और ओएस से प्राप्त ऑफसेट के साथ .tzinfo की आवृत्ति पर सेट की जाएगी।

यदि self.tzinfo tz है , self.astimezone(tz) स्वयं के बराबर है: दिनांक या समय डेटा का कोई समायोजन नहीं किया जाता है। समय परिणाम स्थानीय समय समय क्षेत्र tz में है , स्वयं के रूप में समान UTC समय का प्रतिनिधित्व करते हुए: astz = dt.astimezone(tz) , astz - astz.utcoffset() में dt - dt.utcoffset() के समान दिनांक और समय डेटा dt - dt.utcoffset()

यदि आप केवल दिनांक और समय डेटा के समायोजन के बिना dt.replace(tzinfo=tz) लिए समय क्षेत्र ऑब्जेक्ट tz संलग्न करना चाहते हैं, तो dt.replace(tzinfo=tz) । यदि आप केवल दिनांक और समय डेटा के रूपांतरण के बिना एक जागरूक dt.replace(tzinfo=None) से समय क्षेत्र ऑब्जेक्ट को निकालना चाहते हैं, तो dt.replace(tzinfo=None)

ध्यान दें कि tzinfo.fromutc() द्वारा लौटाए गए परिणाम को प्रभावित करने के लिए tzinfo उपवर्ग में डिफ़ॉल्ट tzinfo.fromutc() विधि को ओवरराइड किया जा सकता है। त्रुटि मामलों को नजरअंदाज करना, astimezone() जैसे कार्य करता है:

def astimezone(self, tz):
    if self.tzinfo is tz:
        return self
    # Convert self to UTC, and attach the new time zone object.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # Convert from UTC to tz's local time.
    return tz.fromutc(utc)

संस्करण 3.3 में परिवर्तित: tz अब छोड़ा जा सकता है।

संस्करण 3.6 में परिवर्तित: astimezone() विधि अब अनुभवहीन उदाहरणों कि प्रणाली स्थानीय समय का प्रतिनिधित्व करने के माना जाता है पर कहा जा सकता है।

datetime.utcoffset()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.utcoffset(self) , और अगर बाद वापस नहीं करता है एक अपवाद को जन्म देती है None एक या timedelta एक दिन से भी कम समय परिमाण के साथ वस्तु।

संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

datetime.dst()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.dst(self) , और अगर बाद वापस नहीं करता है एक अपवाद को जन्म देती है None एक या timedelta एक दिन से भी कम समय परिमाण के साथ वस्तु।

संस्करण 3.7 में परिवर्तित: DST ऑफ़सेट पूरे कई मिनट तक सीमित नहीं है।

datetime.tzname()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.tzname(self) , एक अपवाद है, तो बाद वापस नहीं करता है को जन्म देती है None या एक स्ट्रिंग वस्तु,

datetime.timetuple()

लौटें एक time.struct_time के रूप में इस तरह के द्वारा दिया time.localtime() d.timetuple() के बराबर है time.struct_time((d.year, d.month, d.day, d.hour, d.minute, d.second, d.weekday(), yday, dst)) , जहां 1 जनवरी से yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 शुरू होने वाले चालू वर्ष के भीतर दिन की संख्या है 1tm_isdst परिणाम के ध्वज के अनुसार सेट कर दिया जाता dst() विधि: tzinfo है None या dst() रिटर्न None , tm_isdst पर सेट है -1 ; यदि dst() कोई गैर-शून्य मान लौटाता है, तो tm_isdst उसे सेट किया जाता है 1 ; और tm_isdst पर सेट है 0

datetime.utctimetuple()

अगर datetime उदाहरण d भोला है, तो यह वैसा ही है, d.timetuple() सिवाय इसके कि tm_isdst 0 के लिए मजबूर किया जाए, चाहे जो भी d.dst() रिटर्न मिले। यूटीसी समय के लिए डीएसटी कभी लागू नहीं होता है।

यदि d अवगत है, तो को यूटीसी समय के लिए सामान्यीकृत किया जाता है d.utcoffset() , घटाकर और time.struct_time सामान्यीकृत समय के लिए वापस कर दिया जाता है। tm_isdst को मजबूर किया जाता है। ध्यान दें कि OverflowError यदि d .year था MINYEAR या MAXYEAR UTC समायोजन एक वर्ष की सीमा से अधिक हो तो नोट उठाया जा सकता है ।

datetime.toordinal()

तारीख के प्रोलेप्टिक ग्रेगोरियन ऑर्डिनल को लौटाएं। के रूप में ही self.date().toordinal()

datetime.timestamp()

datetime उदाहरण के लिए POSIX टाइमस्टैम्प लौटें । वापसी मूल्य float उसी के समान है जो कि लौटा है time.time()

datetime स्थानीय समय का प्रतिनिधित्व करने के लिए Naive उदाहरणों को माना जाता है और यह विधि mktime() रूपांतरण करने के लिए प्लेटफ़ॉर्म C फ़ंक्शन पर निर्भर करती है । चूंकि कई प्लेटफार्मों की datetime तुलना में मूल्यों की व्यापक श्रेणी का समर्थन करता mktime() है, इसलिए यह विधि OverflowError अतीत में या भविष्य में बहुत दूर तक बढ़ सकती है ।

जागरूक datetime उदाहरणों के लिए, वापसी मूल्य की गणना निम्नानुसार की जाती है:

(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

संस्करण 3.3 में नया।

संस्करण 3.6 में परिवर्तित: timestamp() विधि का उपयोग करता fold एक दोहराया अंतराल के दौरान कई बार स्पष्ट करने के लिए विशेषता।

ध्यान दें

datetime UTC समय का प्रतिनिधित्व करने वाले एक भोले उदाहरण से सीधे POSIX टाइमस्टैम्प प्राप्त करने की कोई विधि नहीं है । यदि आपका एप्लिकेशन इस कन्वेंशन का उपयोग करता है और आपका सिस्टम टाइमज़ोन UTC के लिए सेट नहीं है, तो आप POSIX टाइमस्टैम्प को tzinfo=timezone.utc निम्न द्वारा प्राप्त कर सकते हैं

timestamp = dt.replace(tzinfo=timezone.utc).timestamp()

या सीधे टाइमस्टैम्प की गणना करके:

timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)
datetime.weekday()

सप्ताह के दिन को पूर्णांक के रूप में लौटाएं, जहां सोमवार 0 है और रविवार 6. समान है self.date().weekday() । यह भी देखें isoweekday()

datetime.isoweekday()

सप्ताह के दिन को पूर्णांक के रूप में लौटाएं, जहां सोमवार 1 और रविवार 7. समान है self.date().isoweekday() । यह भी देखें weekday() , isocalendar()

datetime.isocalendar()

3-टपल लौटें, (आईएसओ वर्ष, आईएसओ सप्ताह संख्या, आईएसओ कार्यदिवस)। के रूप में ही self.date().isocalendar()

datetime.isoformat(sep='T', timespec='auto')

ISO 8601 प्रारूप, YYYY-MM-DDTHH: MM: SS.ffffff या, यदि microsecond 0 है, तो YYYY-MM-DDTHH: MM: SS

यदि utcoffset() वापस नहीं आता है None , तो एक तार जोड़ दिया जाता है, जो यूटीसी ऑफसेट देता है: YYYY-MM-DDTHH: MM: SS.ffffff + HH: MM [: SS [.ffffff]] या, यदि microsecond 0 YYYY-MM-DDTHH: MM है। : SS + HH: MM [: एसएस [.ffffff]]।

वैकल्पिक तर्क sep (डिफ़ॉल्ट 'T' ) एक चरित्र-विभाजक है, जो परिणाम की तारीख और समय के भागों के बीच रखा गया है। उदाहरण के लिए,

>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     def utcoffset(self, dt): return timedelta(minutes=-399)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'

वैकल्पिक तर्क टाइमस्पेस को शामिल करने के लिए समय के अतिरिक्त घटकों की संख्या निर्दिष्ट करता है (डिफ़ॉल्ट है 'auto' )। यह निम्नलिखित में से एक हो सकता है:

  • 'auto' : जैसे 'seconds' कि microsecond 0 है, वैसे ही 'microseconds'
  • 'hours' : hour दो अंकों के एचएच प्रारूप में शामिल करें ।
  • 'minutes' : शामिल करें hour और minute एचएच में: एमएम प्रारूप।
  • 'seconds' : शामिल करें hour , minute और second एचएच में: एमएम: एसएस प्रारूप।
  • 'milliseconds' : पूरे समय को शामिल करें, लेकिन अंश को दूसरे भाग में छोटा करें। HH: MM: SS.sss प्रारूप।
  • 'microseconds' : HH: MM: SS.ffffff प्रारूप में पूर्णकालिक शामिल करें।

ध्यान दें

निकाले गए समय घटकों को काट दिया जाता है, गोल नहीं।

ValueError अमान्य टाइमपास तर्क पर उठाया जाएगा ।

>>> from datetime import datetime
>>> datetime.now().isoformat(timespec='minutes')   
'2002-12-25T00:00'
>>> dt = datetime(2015, 1, 1, 12, 30, 59, 0)
>>> dt.isoformat(timespec='microseconds')
'2015-01-01T12:30:59.000000'

संस्करण 3.6 में नया: टाइमपास तर्क जोड़ा गया ।

datetime.__str__()

एक के लिए datetime उदाहरण , str(d) के बराबर है d.isoformat(' ')

datetime.ctime()

उदाहरण के लिए, दिनांक और समय का प्रतिनिधित्व करते हुए एक स्ट्रिंग लौटें datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec 4 20:30:40 2002'd.ctime() उन time.ctime(time.mktime(d.timetuple())) प्लेटफ़ॉर्म पर समतुल्य है जहाँ देशी C ctime() फ़ंक्शन (जो इनवोक करता है time.ctime() , लेकिन जो datetime.ctime() इनवोक नहीं करता है) C मानक के अनुरूप है।

datetime.strftime(format)

स्पष्ट प्रारूप स्ट्रिंग द्वारा नियंत्रित दिनांक और समय का प्रतिनिधित्व करते हुए एक स्ट्रिंग लौटें। फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें

datetime.__format__(format)

के रूप में ही datetime.strftime() । यह स्वरूपित स्ट्रिंग शाब्दिक और उपयोग करते समय किसी datetime ऑब्जेक्ट के लिए एक प्रारूप स्ट्रिंग निर्दिष्ट करना संभव बनाता है । फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें str.format()

डेटाइम वस्तुओं के साथ काम करने के उदाहरण:

>>> from datetime import datetime, date, time
>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now() or datetime.utcnow()
>>> datetime.now()   
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.utcnow()   
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:   
...     print(it)
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:   
...     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday
>>> # Formatting datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'

Tzinfo के साथ डेटाटाइम का उपयोग करना:

>>> from datetime import timedelta, datetime, tzinfo
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1) + self.dst(dt)
...     def dst(self, dt):
...         # DST starts last Sunday in March
...         d = datetime(dt.year, 4, 1)   # ends last Sunday in October
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...          return "GMT +1"
...
>>> class GMT2(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=2) + self.dst(dt)
...     def dst(self, dt):
...         d = datetime(dt.year, 4, 1)
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...         return "GMT +2"
...
>>> gmt1 = GMT1()
>>> # Daylight Saving Time
>>> dt1 = datetime(2006, 11, 21, 16, 30, tzinfo=gmt1)
>>> dt1.dst()
datetime.timedelta(0)
>>> dt1.utcoffset()
datetime.timedelta(seconds=3600)
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=gmt1)
>>> dt2.dst()
datetime.timedelta(seconds=3600)
>>> dt2.utcoffset()
datetime.timedelta(seconds=7200)
>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(GMT2())
>>> dt3     
datetime.datetime(2006, 6, 14, 14, 0, tzinfo=<GMT2 object at 0x...>)
>>> dt2     
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=<GMT1 object at 0x...>)
>>> dt2.utctimetuple() == dt3.utctimetuple()
True

समय वस्तुओं

एक समय ऑब्जेक्ट दिन के स्थानीय (स्थानीय) समय का प्रतिनिधित्व करता है, किसी विशेष दिन से स्वतंत्र होता है, और एक tzinfo वस्तु के माध्यम से समायोजन के अधीन होता है ।

class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

सभी तर्क वैकल्पिक हैं। tzinfo हो सकता है None , या एक tzinfo उपवर्ग का उदाहरण हो सकता है । शेष तर्क पूर्णांक हो सकते हैं, निम्न श्रेणी में:

  • 0 <= hour < 24 ,
  • 0 <= minute < 60 ,
  • 0 <= second < 60 ,
  • 0 <= microsecond < 1000000 ,
  • fold in [0, 1]

यदि उन सीमाओं के बाहर एक तर्क दिया जाता है, ValueError तो उठाया जाता है। डिफ़ॉल्ट रूप से tzinfo को 0 छोड़कर , जो चूक करता है । None

वर्ग विशेषताएं:

time.min

जल्द से जल्द प्रदर्शनीय time , time(0, 0, 0, 0)

time.max

नवीनतम प्रदर्शनीय time , time(23, 59, 59, 999999)

time.resolution

गैर-बराबर time वस्तुओं के बीच सबसे छोटा संभव अंतर timedelta(microseconds=1) , हालांकि ध्यान दें कि time वस्तुओं पर अंकगणित समर्थित नहीं है।

उदाहरण विशेषताएँ (केवल पढ़ने के लिए):

time.hour

में range(24)

time.minute

में range(60)

time.second

में range(60)

time.microsecond

में range(1000000)

time.tzinfo

ऑब्जेक्ट tzinfo तर्क के रूप में कंस्ट्रक्टर के पास गया time , या None यदि कोई भी पारित नहीं हुआ।

time.fold

में [0, 1] । बार-बार अंतराल के दौरान दीवार के समय को भंग करने के लिए उपयोग किया जाता है। (बार-बार अंतराल तब होता है जब घड़ियों को दिन के समय की बचत के अंत में वापस लुढ़काया जाता है या जब राजनीतिक कारणों से वर्तमान क्षेत्र के लिए यूटीसी ऑफसेट कम हो जाता है।) मान 0 (1) दो क्षणों के पहले (बाद में) का प्रतिनिधित्व करता है एक ही दीवार समय प्रतिनिधित्व।

संस्करण 3.6 में नया।

समर्थित संचालन:

  • की तुलना time करने के लिए time है, जहां एक की तुलना में कम माना जाता है जब एक के बाद आती है के समय में। यदि एक तुलना भोली है और दूसरे को पता है, TypeError तो एक आदेश तुलना का प्रयास करने पर उठाया जाता है। समानता तुलना के लिए, भोले उदाहरण कभी भी जागरूक उदाहरणों के बराबर नहीं होते हैं।

    यदि दोनों तुलनाओं के बारे में पता है, और उनकी tzinfo विशेषता समान है, तो सामान्य tzinfo विशेषता को अनदेखा किया जाता है और आधार समय की तुलना की जाती है। यदि दोनों तुलनाओं के बारे में पता है और अलग-अलग tzinfo विशेषताएं हैं, तो तुलनाओं को पहले उनके यूटीसी ऑफसेट (प्राप्त self.utcoffset() ) से घटाकर समायोजित किया जाता है । मिश्रित प्रकार की तुलनाओं को ऑब्जेक्ट एड्रेस द्वारा डिफ़ॉल्ट तुलना में वापस गिरने से रोकने के लिए, जब किसी time ऑब्जेक्ट की तुलना किसी अन्य प्रकार की वस्तु से की जाती है, TypeError तब तक उठाया जाता है जब तक कि तुलना == या नहीं होती != । उत्तरार्द्ध मामले क्रमशः लौटते हैं False या True , क्रमशः।

    संस्करण 3.3 में बदला: भोले और जागरूक time उदाहरणों के बीच समानता की तुलना नहीं करते हैं TypeError

  • हैश, तानाशाही कुंजी के रूप में उपयोग करें
  • कुशल अचार

बूलियन संदर्भों में, एक time वस्तु को हमेशा सच माना जाता है।

संस्करण 3.5 में बदला: पायथन 3.5 से पहले, एक time वस्तु को झूठा माना जाता था यदि वह UTC में मध्यरात्रि का प्रतिनिधित्व करती थी। इस व्यवहार को अस्पष्ट और त्रुटिपूर्ण माना गया और इसे पायथन 3.5 में हटा दिया गया है। देखें bpo-13936 पूर्ण विवरण के लिए।

अन्य निर्माता:

classmethod time.fromisoformat(time_string)

इसके द्वारा उत्सर्जित स्वरूपों में time से एक में time_string के लिए संबंधित रिटर्न time.isoformat() । विशेष रूप से, यह फ़ंक्शन प्रारूप (एस) में तार का समर्थन करता है HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

सावधान

यह आईएसओ 8601 स्ट्रिंग्स को मनमाने ढंग से पार्स करने का समर्थन नहीं करता है - यह केवल उलटा ऑपरेशन के रूप में करना है time.isoformat()

संस्करण 3.7 में नया।

उदाहरण के तरीके:

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)

time समान मानों के साथ लौटें , उन विशेषताओं को छोड़कर, जिनमें से कोई भी नए तर्क दिए गए हैं। ध्यान दें कि समय डेटा के रूपांतरण के बिना, एक जागरूक से tzinfo=None एक भोला बनाने के लिए निर्दिष्ट किया जा सकता है । time time

संस्करण 3.6 में नया: fold तर्क जोड़ा गया ।

time.isoformat(timespec='auto')

ISO 8601 प्रारूप में समय का प्रतिनिधित्व करते हुए एक स्ट्रिंग लौटाएं, HH: MM: SS.ffffff या, यदि microsecond 0, HH: MM: SS है, तो utcoffset() वापस नहीं आता है None , एक स्ट्रिंग जोड़ा जाता है, जिससे UTC ऑफसेट: HH: MM: SS। ffffff + HH: MM [: SS [.ffffff]] या, अगर self.microsecond 0 है, HH: MM: SS + HH: MM [: SS [.ffffff]]।

वैकल्पिक तर्क टाइमस्पेस को शामिल करने के लिए समय के अतिरिक्त घटकों की संख्या निर्दिष्ट करता है (डिफ़ॉल्ट है 'auto' )। यह निम्नलिखित में से एक हो सकता है:

  • 'auto' : जैसे 'seconds' कि microsecond 0 है, वैसे ही 'microseconds'
  • 'hours' : hour दो अंकों के एचएच प्रारूप में शामिल करें ।
  • 'minutes' : शामिल करें hour और minute एचएच में: एमएम प्रारूप।
  • 'seconds' : शामिल करें hour , minute और second एचएच में: एमएम: एसएस प्रारूप।
  • 'milliseconds' : पूरे समय को शामिल करें, लेकिन अंश को दूसरे भाग में छोटा करें। HH: MM: SS.sss प्रारूप।
  • 'microseconds' : HH: MM: SS.ffffff प्रारूप में पूर्णकालिक शामिल करें।

ध्यान दें

निकाले गए समय घटकों को काट दिया जाता है, गोल नहीं।

ValueError अमान्य टाइमपास तर्क पर उठाया जाएगा ।

>>> from datetime import time
>>> time(hour=12, minute=34, second=56, microsecond=123456).isoformat(timespec='minutes')
'12:34'
>>> dt = time(hour=12, minute=34, second=56, microsecond=0)
>>> dt.isoformat(timespec='microseconds')
'12:34:56.000000'
>>> dt.isoformat(timespec='auto')
'12:34:56'

संस्करण 3.6 में नया: टाइमपास तर्क जोड़ा गया ।

time.__str__()

एक समय टी के लिए , str(t) के बराबर है t.isoformat()

time.strftime(format)

समय का प्रतिनिधित्व करते हुए एक स्ट्रिंग लौटें, एक स्पष्ट प्रारूप स्ट्रिंग द्वारा नियंत्रित। फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें

time.__format__(format)

के रूप में ही time.strftime() । यह स्वरूपित स्ट्रिंग शाब्दिक और उपयोग करते समय किसी time ऑब्जेक्ट के लिए एक प्रारूप स्ट्रिंग निर्दिष्ट करना संभव बनाता है । फ़ॉर्मेटिंग निर्देशों की पूरी सूची के लिए, स्ट्रैफ़ाइम () और स्ट्रैपटाइम () व्यवहार देखें str.format()

time.utcoffset()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.utcoffset(None) , और अगर बाद वापस नहीं करता है एक अपवाद को जन्म देती है None एक या timedelta एक दिन से भी कम समय परिमाण के साथ वस्तु।

संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

time.dst()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.dst(None) , और एक अपवाद है, तो बाद वापस नहीं करता है को जन्म देती है None , या एक timedelta एक दिन से भी कम समय परिमाण के साथ वस्तु।

संस्करण 3.7 में परिवर्तित: DST ऑफ़सेट पूरे कई मिनट तक सीमित नहीं है।

time.tzname()

अगर tzinfo है None , रिटर्न None , और रिटर्न self.tzinfo.tzname(None) , या अपवाद अगर दूसरी स्थिति वापस नहीं करता है को जन्म देती है None या एक स्ट्रिंग वस्तु।

उदाहरण:

>>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self,dt):
...         return "Europe/Prague"
...
>>> t = time(12, 10, 30, tzinfo=GMT1())
>>> t                               
datetime.time(12, 10, 30, tzinfo=<GMT1 object at 0x...>)
>>> gmt = GMT1()
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'Europe/Prague'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 Europe/Prague'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 12:10.'

tzinfo ऑब्जेक्ट्स

class datetime.tzinfo

यह एक सार आधार वर्ग है, जिसका अर्थ है कि इस वर्ग को सीधे नहीं किया जाना चाहिए। आपको एक ठोस उपवर्ग प्राप्त करने की आवश्यकता है, और आपके tzinfo द्वारा datetime उपयोग की जाने वाली विधियों द्वारा आवश्यक मानक विधियों के कम से कम आपूर्ति कार्यान्वयन । datetime मॉड्यूल का एक सरल ठोस उपवर्ग की आपूर्ति tzinfo , timezone है, जो तय ऐसे यूटीसी खुद या उत्तर अमेरिकी ईएसटी और EDT के रूप में यूटीसी से ऑफसेट समय क्षेत्र का प्रतिनिधित्व कर सकते हैं।

(और एक ठोस उपवर्ग) का एक उदाहरण tzinfo निर्माणकर्ताओं को वस्तुओं datetime और time वस्तुओं के लिए पारित किया जा सकता है । उत्तरार्द्ध वस्तुएं स्थानीय समय में होने के रूप में अपनी विशेषताओं को देखती हैं, और tzinfo वस्तु यूटीसी से स्थानीय समय की ऑफसेटिंग, समय क्षेत्र का नाम और डीएसटी ऑफसेट के सभी तरीकों का पता लगाने के तरीकों का समर्थन करती है, जो उनके पास एक तिथि या समय वस्तु के सापेक्ष है।

अचार बनाने के लिए विशेष आवश्यकता: एक tzinfo उपवर्ग में एक __init__() विधि होनी चाहिए जिसे बिना किसी तर्क के कहा जा सकता है, अन्यथा इसे चुना जा सकता है लेकिन संभवतः फिर से अनपिक नहीं किया जा सकता है। यह एक तकनीकी आवश्यकता है जिसे भविष्य में आराम दिया जा सकता है।

tzinfo निम्नलिखित विधियों को लागू करने के लिए एक ठोस उपवर्ग की आवश्यकता हो सकती है। वास्तव में किन तरीकों की आवश्यकता है, यह जागरूक datetime वस्तुओं के उपयोग पर निर्भर करता है । यदि संदेह है, तो बस उन सभी को लागू करें।

tzinfo.utcoffset(dt)

UTC से स्थानीय समय की ऑफ़सेट वापसी, एक ऐसी timedelta वस्तु के रूप में जो UTC के पूर्व में सकारात्मक है। यदि स्थानीय समय UTC के पश्चिम में है, तो यह नकारात्मक होना चाहिए। ध्यान दें कि यह यूटीसी से कुल ऑफसेट होने का इरादा है; उदाहरण के लिए, यदि कोई tzinfo वस्तु समय क्षेत्र और डीएसटी समायोजन दोनों का प्रतिनिधित्व करती है, तो utcoffset() उन्हें अपनी राशि वापस करनी चाहिए। यदि UTC ऑफसेट ज्ञात नहीं है, तो वापस लौटें None । बदले में दिया गया मान के timedelta बीच कड़ाई से एक वस्तु होनी चाहिए -timedelta(hours=24) और timedelta(hours=24) (ऑफसेट की परिमाण एक दिन से कम होनी चाहिए)। अधिकांश कार्यान्वयन utcoffset() शायद इन दोनों में से एक की तरह दिखेंगे:

return CONSTANT                 # fixed-offset class
return CONSTANT + self.dst(dt)  # daylight-aware class

तो utcoffset() वापस नहीं करता है None , dst() वापस नहीं जाना चाहिए None या तो।

डिफ़ॉल्ट कार्यान्वयन का utcoffset() उदय होता है NotImplementedError

संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

tzinfo.dst(dt)

डेलाइट सेविंग टाइम (DST) समायोजन को एक timedelta वस्तु के रूप में लौटाएं या None यदि DST की जानकारी नहीं है। timedelta(0) यदि डीएसटी प्रभाव में नहीं है तो लौटें । यदि डीएसटी प्रभाव में है, तो ऑफसेट को एक timedelta वस्तु के रूप में लौटाएं ( utcoffset() विवरण के लिए देखें)। ध्यान दें कि डीएसटी ऑफसेट, यदि लागू हो, पहले से वापस किए गए यूटीसी ऑफसेट में जोड़ दिया गया है utcoffset() , इसलिए dst() जब तक आप डीएसटी जानकारी अलग से प्राप्त करने में रुचि नहीं लेते, तब तक परामर्श करने की आवश्यकता नहीं है । उदाहरण के लिए, ध्वज को कैसे सेट किया जाना चाहिए, यह निर्धारित करने के लिए datetime.timetuple() इसकी tzinfo विशेषता dst() विधि को कॉल करता है tm_isdst , और समय क्षेत्रों को पार करते समय डीएसटी परिवर्तनों के लिए खाते में tzinfo.fromutc() कॉल dst() करता है।

एक उपवर्ग का एक उदाहरण tz tzinfo जो मानक और दिन के समय दोनों के मॉडल को इस अर्थ में सुसंगत होना चाहिए:

tz.utcoffset(dt) - tz.dst(dt)

हर के लिए एक ही परिणाम लौटना चाहिए डीटी के साथ समझदार के लिए उपवर्गों, इस अभिव्यक्ति समय क्षेत्र के "मानक ऑफसेट" है, जो दिनांक या समय पर निर्भर नहीं करना चाहिए, लेकिन केवल भौगोलिक स्थिति के अर्जित करता है। इस पर निर्भरता का कार्यान्वयन , लेकिन उल्लंघन का पता नहीं लगा सकता है; यह सुनिश्चित करना प्रोग्रामर की जिम्मेदारी है। यदि कोई उपवर्ग इसकी गारंटी नहीं दे सकता है, तो यह सही ढंग से कार्य के डिफ़ॉल्ट कार्यान्वयन को ओवरराइड करने में सक्षम हो सकता है, भले ही इसके साथ सही ढंग से काम न किया हो। datetime dt.tzinfo == tz tzinfo astimezone() tzinfo tzinfo.fromutc() astimezone()

अधिकांश कार्यान्वयन dst() शायद इन दोनों में से एक की तरह दिखेंगे:

def dst(self, dt):
    # a fixed-offset class:  doesn't account for DST
    return timedelta(0)

या

def dst(self, dt):
    # Code to set dston and dstoff to the time zone's DST
    # transition times based on the input dt.year, and expressed
    # in standard local time.  Then

    if dston <= dt.replace(tzinfo=None) < dstoff:
        return timedelta(hours=1)
    else:
        return timedelta(0)

डिफ़ॉल्ट कार्यान्वयन का dst() उदय होता है NotImplementedError

संस्करण 3.7 में परिवर्तित: DST ऑफ़सेट पूरे कई मिनट तक सीमित नहीं है।

tzinfo.tzname(dt)

स्ट्रिंग के रूप में datetime ऑब्जेक्ट dt के अनुरूप समय क्षेत्र नाम लौटाएं । स्ट्रिंग नामों के बारे में कुछ भी datetime मॉड्यूल द्वारा परिभाषित नहीं किया गया है, और इसकी कोई आवश्यकता नहीं है कि इसका विशेष रूप से मतलब है। उदाहरण के लिए, "GMT", "UTC", "-500", "-5: 00", "EDT", "US / पूर्वी", "अमेरिका / न्यूयॉर्क" सभी मान्य उत्तर हैं। None यदि कोई स्ट्रिंग नाम ज्ञात नहीं है, तो वापस लौटें । ध्यान दें कि यह मुख्य रूप से एक निश्चित स्ट्रिंग के बजाय एक विधि है क्योंकि कुछ tzinfo उपवर्ग अलग-अलग नामों को वापस करने की इच्छा करेंगे , जो विशेष रूप से उत्तीर्ण dt के विशिष्ट मूल्य के आधार पर होंगे , खासकर यदि tzinfo वर्ग दिन के समय का हिसाब कर रहा हो।

डिफ़ॉल्ट कार्यान्वयन का tzname() उदय होता है NotImplementedError

इन विधियों को एक ही नाम के उनके तरीकों के जवाब में, किसी ऑब्जेक्ट datetime या time ऑब्जेक्ट द्वारा बुलाया जाता है । एक datetime वस्तु अपने आप को तर्क के रूप में पारित करती है, और एक time वस्तु None तर्क के रूप में गुजरती है। एक tzinfo उपवर्ग के तरीकों इसलिए एक को स्वीकार करने के लिए तैयार रहना चाहिए डीटी का तर्क None , या वर्ग के datetime

जब None इसे पारित किया जाता है, तो यह सर्वश्रेष्ठ प्रतिक्रिया तय करने के लिए क्लास डिजाइनर तक है। उदाहरण के लिए, लौटाना None उचित है यदि वर्ग यह कहना चाहता है कि समय tzinfo प्रोटोकॉल में भाग नहीं लेते हैं । utcoffset(None) मानक यूटीसी ऑफसेट को वापस करने के लिए यह अधिक उपयोगी हो सकता है , क्योंकि मानक ऑफसेट की खोज के लिए कोई अन्य सम्मेलन नहीं है।

जब किसी विधि के datetime जवाब में किसी वस्तु को पास किया जाता है, तो वही वस्तु स्वयं के रूप में होती है । तरीके इस पर भरोसा कर सकते हैं, जब तक कि उपयोगकर्ता कोड सीधे तरीकों को कॉल न करें । आशय यह है कि तरीकों की व्याख्या डीटी के रूप में स्थानीय समय में किया जा रहा है, और अन्य समय क्षेत्र में वस्तुओं के बारे में चिंता की जरूरत नहीं। datetime dt.tzinfo tzinfo tzinfo tzinfo

एक और tzinfo विधि है जो एक उपवर्ग को ओवरराइड करने की इच्छा कर सकती है:

tzinfo.fromutc(dt)

इसे डिफ़ॉल्ट astimezone() कार्यान्वयन से कहा जाता है । जब कि से कहा जाता है, dt.tzinfo है स्वयं , और डीटी की तिथि और समय डेटा कर रहे हैं एक UTC समय व्यक्त के रूप में देखा जाना चाहिए। इसका उद्देश्य स्वयं के स्थानीय समय tzinfo.fromutc() में समतुल्य डेटाटाइम लौटाते हुए दिनांक और समय डेटा को समायोजित करना है ।

अधिकांश tzinfo उपवर्गों को tzinfo.fromutc() समस्याओं के बिना डिफ़ॉल्ट कार्यान्वयन को प्राप्त करने में सक्षम होना चाहिए । यह तय-ऑफ़ टाइम ज़ोन को संभालने के लिए पर्याप्त मजबूत है, और मानक और डेलाइट समय दोनों के लिए टाइम ज़ोन का लेखा-जोखा है, और बाद में भी जब DST संक्रमण समय अलग-अलग वर्षों में भिन्न होता है। समय क्षेत्र का एक उदाहरण डिफ़ॉल्ट tzinfo.fromutc() कार्यान्वयन सभी मामलों में सही ढंग से संभाल नहीं सकता है, जहां मानक ऑफसेट (यूटीसी से) विशिष्ट तिथि और समय बीतने पर निर्भर करता है, जो राजनीतिक कारणों से हो सकता है। के डिफ़ॉल्ट कार्यान्वयन astimezone() और tzinfo.fromutc() परिणाम आप चाहते हैं, तो परिणाम घंटे पल मानक परिवर्तन ऑफसेट straddling में से एक है का उत्पादन नहीं कर सकते हैं।

त्रुटि मामलों के लिए स्किपिंग कोड, डिफ़ॉल्ट tzinfo.fromutc() कार्यान्वयन जैसे कार्य करता है:

def fromutc(self, dt):
    # raise ValueError error if dt.tzinfo is not self
    dtoff = dt.utcoffset()
    dtdst = dt.dst()
    # raise ValueError if dtoff is None or dtdst is None
    delta = dtoff - dtdst  # this is self's standard offset
    if delta:
        dt += delta   # convert to standard local time
        dtdst = dt.dst()
        # raise ValueError if dtdst is None
    if dtdst:
        return dt + dtdst
    else:
        return dt

निम्न tzinfo_examples.py फ़ाइल में tzinfo कक्षाओं के कुछ उदाहरण हैं:

from datetime import tzinfo, timedelta, datetime

ZERO = timedelta(0)
HOUR = timedelta(hours=1)
SECOND = timedelta(seconds=1)

# A class capturing the platform's idea of local time.
# (May result in wrong values on historical times in
#  timezones where UTC offset and/or the DST rules had
#  changed in the past.)
import time as _time

STDOFFSET = timedelta(seconds = -_time.timezone)
if _time.daylight:
    DSTOFFSET = timedelta(seconds = -_time.altzone)
else:
    DSTOFFSET = STDOFFSET

DSTDIFF = DSTOFFSET - STDOFFSET

class LocalTimezone(tzinfo):

    def fromutc(self, dt):
        assert dt.tzinfo is self
        stamp = (dt - datetime(1970, 1, 1, tzinfo=self)) // SECOND
        args = _time.localtime(stamp)[:6]
        dst_diff = DSTDIFF // SECOND
        # Detect fold
        fold = (args == _time.localtime(stamp - dst_diff))
        return datetime(*args, microsecond=dt.microsecond,
                        tzinfo=self, fold=fold)

    def utcoffset(self, dt):
        if self._isdst(dt):
            return DSTOFFSET
        else:
            return STDOFFSET

    def dst(self, dt):
        if self._isdst(dt):
            return DSTDIFF
        else:
            return ZERO

    def tzname(self, dt):
        return _time.tzname[self._isdst(dt)]

    def _isdst(self, dt):
        tt = (dt.year, dt.month, dt.day,
              dt.hour, dt.minute, dt.second,
              dt.weekday(), 0, 0)
        stamp = _time.mktime(tt)
        tt = _time.localtime(stamp)
        return tt.tm_isdst > 0

Local = LocalTimezone()


# A complete implementation of current DST rules for major US time zones.

def first_sunday_on_or_after(dt):
    days_to_go = 6 - dt.weekday()
    if days_to_go:
        dt += timedelta(days_to_go)
    return dt


# US DST Rules
#
# This is a simplified (i.e., wrong for a few cases) set of rules for US
# DST start and end times. For a complete and up-to-date set of DST rules
# and timezone definitions, visit the Olson Database (or try pytz):
# http://www.twinsun.com/tz/tz-link.htm
# http://sourceforge.net/projects/pytz/ (might not be up-to-date)
#
# In the US, since 2007, DST starts at 2am (standard time) on the second
# Sunday in March, which is the first Sunday on or after Mar 8.
DSTSTART_2007 = datetime(1, 3, 8, 2)
# and ends at 2am (DST time) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 2)
# From 1987 to 2006, DST used to start at 2am (standard time) on the first
# Sunday in April and to end at 2am (DST time) on the last
# Sunday of October, which is the first Sunday on or after Oct 25.
DSTSTART_1987_2006 = datetime(1, 4, 1, 2)
DSTEND_1987_2006 = datetime(1, 10, 25, 2)
# From 1967 to 1986, DST used to start at 2am (standard time) on the last
# Sunday in April (the one on or after April 24) and to end at 2am (DST time)
# on the last Sunday of October, which is the first Sunday
# on or after Oct 25.
DSTSTART_1967_1986 = datetime(1, 4, 24, 2)
DSTEND_1967_1986 = DSTEND_1987_2006

def us_dst_range(year):
    # Find start and end times for US DST. For years before 1967, return
    # start = end for no DST.
    if 2006 < year:
        dststart, dstend = DSTSTART_2007, DSTEND_2007
    elif 1986 < year < 2007:
        dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
    elif 1966 < year < 1987:
        dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
    else:
        return (datetime(year, 1, 1), ) * 2

    start = first_sunday_on_or_after(dststart.replace(year=year))
    end = first_sunday_on_or_after(dstend.replace(year=year))
    return start, end


class USTimeZone(tzinfo):

    def __init__(self, hours, reprname, stdname, dstname):
        self.stdoffset = timedelta(hours=hours)
        self.reprname = reprname
        self.stdname = stdname
        self.dstname = dstname

    def __repr__(self):
        return self.reprname

    def tzname(self, dt):
        if self.dst(dt):
            return self.dstname
        else:
            return self.stdname

    def utcoffset(self, dt):
        return self.stdoffset + self.dst(dt)

    def dst(self, dt):
        if dt is None or dt.tzinfo is None:
            # An exception may be sensible here, in one or both cases.
            # It depends on how you want to treat them.  The default
            # fromutc() implementation (called by the default astimezone()
            # implementation) passes a datetime with dt.tzinfo is self.
            return ZERO
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        dt = dt.replace(tzinfo=None)
        if start + HOUR <= dt < end - HOUR:
            # DST is in effect.
            return HOUR
        if end - HOUR <= dt < end:
            # Fold (an ambiguous hour): use dt.fold to disambiguate.
            return ZERO if dt.fold else HOUR
        if start <= dt < start + HOUR:
            # Gap (a non-existent hour): reverse the fold rule.
            return HOUR if dt.fold else ZERO
        # DST is off.
        return ZERO

    def fromutc(self, dt):
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        start = start.replace(tzinfo=self)
        end = end.replace(tzinfo=self)
        std_time = dt + self.stdoffset
        dst_time = std_time + HOUR
        if end <= dst_time < end + HOUR:
            # Repeated hour
            return std_time.replace(fold=1)
        if std_time < start or dst_time >= end:
            # Standard time
            return std_time
        if start <= std_time < end - HOUR:
            # Daylight saving time
            return dst_time


Eastern  = USTimeZone(-5, "Eastern",  "EST", "EDT")
Central  = USTimeZone(-6, "Central",  "CST", "CDT")
Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
Pacific  = USTimeZone(-8, "Pacific",  "PST", "PDT")

ध्यान दें कि tzinfo डीजीए संक्रमण बिंदुओं पर दोनों मानक और दिन के समय के लिए एक उपवर्ग लेखांकन में प्रति वर्ष दो बार अपरिहार्य सूक्ष्मताएं होती हैं । सहमति के लिए, यूएस ईस्टर्न (UTC -0500) पर विचार करें, जहां EDT मार्च में दूसरे रविवार को 1:59 (EST) के बाद शुरू होता है, और नवंबर में पहले रविवार को 1:59 (EDT) के बाद मिनट समाप्त होता है:

  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM
  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM
  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM

start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM

  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM

जब DST शुरू होता है ("स्टार्ट" लाइन), लोकल वॉल क्लॉक 1:59 से 3:00 बजे तक चलती है। फॉर्म 2 की दीवार का समय: एमएम वास्तव में उस दिन समझ में नहीं आता है, इसलिए जिस दिन डीएसटी शुरू होता है उस दिन astimezone(Eastern) परिणाम नहीं देगा hour == 2 उदाहरण के लिए, 2016 के वसंत आगे संक्रमण पर, हमें मिलता है

>>> from datetime import datetime, timezone
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = datetime(2016, 3, 13, 5, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname())
...
05:00:00 UTC = 00:00:00 EST
06:00:00 UTC = 01:00:00 EST
07:00:00 UTC = 03:00:00 EDT
08:00:00 UTC = 04:00:00 EDT

जब डीएसटी समाप्त होता है ("अंत" लाइन), एक संभावित रूप से बदतर समस्या है: एक घंटे है जिसे स्थानीय दीवार समय में स्पष्ट रूप से वर्तनी नहीं किया जा सकता है: दिन के अंतिम समय का समय। पूर्वी में, यह फॉर्म 5 का समय है: दिन के उजाले के दिन एमएम यूटीसी समाप्त हो जाता है। स्थानीय दीवार घड़ी 1:59 (दिन के समय) से 1:00 (मानक समय) तक फिर से छलांग लगाती है। प्रपत्र 1 का स्थानीय समय: MM अस्पष्ट हैं। astimezone() दो निकटवर्ती यूटीसी घंटों को एक ही स्थानीय घंटे में मैप करके स्थानीय घड़ी के व्यवहार की नकल करता है। पूर्वी उदाहरण में, फॉर्म 5: एमएम और 6: एमएम के दोनों समय 1: एमएम दोनों मैप 1: एमएम के पूर्वी में परिवर्तित होने पर, लेकिन पहले के समय में fold 0 पर सेट करने की विशेषता है और बाद में इसे 1 पर सेट किया गया है। उदाहरण के लिए, 2016 के पतन वापस संक्रमण पर, हम प्राप्त करते हैं

>>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)
...
04:00:00 UTC = 00:00:00 EDT 0
05:00:00 UTC = 01:00:00 EDT 0
06:00:00 UTC = 01:00:00 EST 1
07:00:00 UTC = 02:00:00 EST 0

ध्यान दें कि datetime केवल fold विशेषता के मूल्य से भिन्न होने वाले उदाहरणों की तुलना में समान माना जाता है।

ऐसे अनुप्रयोग जो दीवार-समय की अस्पष्टताओं को सहन नहीं कर सकते, उन्हें स्पष्ट रूप से fold विशेषता के मूल्य की जांच करनी चाहिए या संकर tzinfo उपवर्गों का उपयोग करने से बचना चाहिए ; उपयोग करते समय कोई अस्पष्टता नहीं होती है timezone , या कोई अन्य निश्चित- tzinfo उप - उपवर्ग (जैसे केवल ईएसटी (निश्चित ऑफसेट -5 घंटे) का प्रतिनिधित्व करने वाला वर्ग, या केवल ईडीटी (निश्चित ऑफसेट -4 घंटे))।

यह भी देखें

dateutil.tz

मानक पुस्तकालय में timezone यूटीसी और timezone.utc यूटीसी टाइमज़ोन उदाहरण के रूप में मनमाने ढंग से निर्धारित ऑफसेट को संभालने के लिए कक्षा है ।

dateutil.tz लाइब्रेरी, पायनॉन के लिए IANA टाइमज़ोन डेटाबेस (जिसे ओल्सन डेटाबेस भी कहा जाता है) लाता है और इसके उपयोग की सिफारिश की जाती है।

IANA टाइमज़ोन डेटाबेस
टाइम ज़ोन डेटाबेस (जिसे अक्सर tz, tzdata या Zoneinfo कहा जाता है) में कोड और डेटा होते हैं जो दुनिया भर के कई प्रतिनिधि स्थानों के लिए स्थानीय समय के इतिहास का प्रतिनिधित्व करते हैं। यह समय-समय पर सीमाओं, यूटीसी कार्यालयों और दिन के उजाले-बचत नियमों के लिए राजनीतिक निकायों द्वारा किए गए परिवर्तनों को प्रतिबिंबित करने के लिए समय-समय पर अद्यतन किया जाता है।

समयक्षेत्र वस्तुओं

timezone वर्ग का एक उपवर्ग है tzinfo , प्रत्येक उदाहरण जिनमें से एक समय क्षेत्र द्वारा एक निश्चित यूटीसी से ऑफसेट परिभाषित प्रतिनिधित्व करता है। ध्यान दें कि इस वर्ग की वस्तुओं का उपयोग उन स्थानों में टाइमज़ोन की जानकारी का प्रतिनिधित्व करने के लिए नहीं किया जा सकता है जहां वर्ष के विभिन्न दिनों में विभिन्न ऑफसेट का उपयोग किया जाता है या जहां नागरिक समय में ऐतिहासिक परिवर्तन किए गए हैं।

class datetime.timezone(offset, name=None)

ऑफसेट तर्क एक के रूप में निर्दिष्ट किया जाना चाहिए timedelta वस्तु स्थानीय समय और UTC के बीच अंतर को दर्शाता है। यह सख्ती के बीच होना चाहिए -timedelta(hours=24) और timedelta(hours=24) , अन्यथा ValueError उठाया जाता है।

नाम तर्क वैकल्पिक है। यदि निर्दिष्ट किया गया है तो यह एक स्ट्रिंग होना चाहिए जो datetime.tzname() विधि द्वारा दिए गए मान के रूप में उपयोग किया जाएगा ।

संस्करण 3.2 में नया।

संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

timezone.utcoffset(dt)

जब timezone उदाहरण का निर्माण किया जाता है , तो निर्दिष्ट मान लौटाएं । डीटी तर्क नजरअंदाज कर दिया है। वापसी मूल्य एक timedelta उदाहरण है जो स्थानीय समय और यूटीसी के बीच अंतर के बराबर है।

संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

timezone.tzname(dt)

जब timezone उदाहरण का निर्माण किया जाता है , तो निर्दिष्ट मान लौटाएं । यदि नाम कंस्ट्रक्टर में प्रदान नहीं किया गया है, तो लौटाया गया नाम निम्न प्रकार tzname(dt) के मान से उत्पन्न होता offset है। यदि ऑफ़सेट है timedelta(0) , तो नाम "UTC" है, अन्यथा यह एक स्ट्रिंग है 'UTC, HH: MM', जहाँ ± का चिन्ह है offset , HH और MM क्रमशः offset.hours और दो अंक offset.minutes हैं।

संस्करण 3.6 में परिवर्तित: offset=timedelta(0) अब से उत्पन्न नाम 'UTC' है, न कि 'UTC + 00: 00'।

timezone.dst(dt)

हमेशा लौटता है None

timezone.fromutc(dt)

वापसी dt + offset डीटी तर्क एक बारे में पता होना चाहिए datetime , उदाहरण के साथ tzinfo करने के लिए सेट self

वर्ग विशेषताएं:

timezone.utc

UTC समयज़ोन, timezone(timedelta(0))

strftime() और strptime() व्यवहार

date , datetime और time ऑब्जेक्ट सभी एक strftime(format) विधि का समर्थन करते हैं, एक स्पष्ट प्रारूप स्ट्रिंग के नियंत्रण के तहत समय का प्रतिनिधित्व करते हुए एक स्ट्रिंग बनाने के लिए। मोटे तौर पर, मॉड्यूल की d.strftime(fmt) तरह कार्य करता है, हालांकि सभी ऑब्जेक्ट एक विधि का समर्थन नहीं करते हैं । time time.strftime(fmt, d.timetuple()) timetuple()

इसके विपरीत, datetime.strptime() वर्ग विधि datetime एक दिनांक और समय और इसी प्रारूप स्ट्रिंग का प्रतिनिधित्व करते हुए स्ट्रिंग से एक ऑब्जेक्ट बनाता है । datetime.strptime(date_string, format) के बराबर है datetime(*(time.strptime(date_string, format)[0:6]))

के लिए time वस्तुओं, वर्ष, माह, और दिन के लिए प्रारूप कोड, नहीं किया जाना चाहिए के रूप में समय की वस्तुओं में ऐसी कोई मान हैं। यदि वे वैसे भी उपयोग किए जाते हैं, 1900 तो वर्ष के लिए प्रतिस्थापित किया जाता है , और 1 महीने और दिन के लिए।

के लिए date वस्तुओं, के लिए घंटे, मिनट, सेकंड, और माइक्रोसेकंड प्रारूप कोड, नहीं किया जाना चाहिए के रूप में date वस्तुओं में ऐसी कोई मान हैं। यदि वे वैसे भी उपयोग किए जाते हैं, 0 तो उनके लिए प्रतिस्थापित किया जाता है।

समर्थित प्रारूप कोड का पूरा सेट प्लेटफ़ॉर्म पर भिन्न होता है, क्योंकि पायथन प्लेटफ़ॉर्म को C लाइब्रेरी का strftime() कार्य कहता है , और प्लेटफ़ॉर्म विविधताएँ आम हैं। अपने प्लेटफ़ॉर्म पर समर्थित प्रारूप कोड का पूरा सेट देखने के लिए, स्ट्रैपटाइम (3) प्रलेखन से परामर्श करें ।

निम्नलिखित सभी प्रारूप कोडों की एक सूची है जो C मानक (1989 संस्करण) की आवश्यकता है, और ये सभी मानक C कार्यान्वयन के साथ सभी प्लेटफार्मों पर काम करते हैं। ध्यान दें कि सी मानक के 1999 संस्करण में अतिरिक्त प्रारूप कोड जोड़े गए थे।

आदेश अर्थ उदाहरण टिप्पणियाँ
%a लोकल के संक्षिप्त नाम के रूप में सप्ताहांत। (1)
%A लोकल का पूरा नाम वीकडे। (1)
%w सप्ताहांत एक दशमलव संख्या के रूप में, जहां 0 रविवार है और 6 शनिवार है। 0, 1,…, 6
%d महीने का दिन शून्य-गद्देदार दशमलव संख्या के रूप में। 01, 02,…, 31
%b लोकेल के संक्षिप्त नाम के रूप में महीना। (1)
%B स्थानीय नाम के रूप में महीना। (1)
%m शून्य-गद्देदार दशमलव संख्या के रूप में महीना। 01, 02,…, 12
%y शून्य-गद्देदार दशमलव संख्या के रूप में सदी के बिना वर्ष। 00, 01,…, 99
%Y एक दशमलव संख्या के रूप में शताब्दी के साथ वर्ष। 0001, 0002,…, 2013, 2014,…, 9998, 9999 (2)
%H शून्य-गद्देदार दशमलव संख्या के रूप में घंटा (24-घंटे की घड़ी)। 00, 01,…, 23
%I शून्य-गद्देदार दशमलव संख्या के रूप में घंटा (12-घंटे की घड़ी)। 01, 02,…, 12
%p लोकेल के बराबर या तो एएम या पीएम। (1), (3)
%M शून्य-गद्देदार दशमलव संख्या के रूप में मिनट। 00, 01,…, 59
%S दूसरा शून्य-गद्देदार दशमलव संख्या के रूप में। 00, 01,…, 59 (4)
%f माइक्रोसेकंड एक दशमलव संख्या के रूप में, बाईं ओर शून्य-गद्देदार। 000000, 000001,…, 999999 (5)
%z UTC फॉर्म में U HHMM [SS [.ffffff]] (यदि स्ट्रिंग भोली है तो खाली स्ट्रिंग)। (खाली), +0000, -0400, +1030, +063415, -030712.345216 (6)
%Z समय क्षेत्र नाम (खाली स्ट्रिंग यदि वस्तु भोली है)। (खाली), यूटीसी, ईएसटी, सीएसटी
%j वर्ष का दिन शून्य-गद्देदार दशमलव संख्या के रूप में। 001, 002,…, 366
%U वर्ष की सप्ताह संख्या (सप्ताह के पहले दिन के रूप में रविवार) शून्य गद्देदार दशमलव संख्या के रूप में। एक नए साल में सभी दिन पहले रविवार से पहले सप्ताह 0 में माने जाते हैं। 00, 01,…, 53 (7)
%W वर्ष की सप्ताह संख्या (सप्ताह के पहले दिन के रूप में सोमवार) एक दशमलव संख्या के रूप में। एक नए साल में सभी दिन पहले सोमवार से पहले सप्ताह 0 में माने जाते हैं। 00, 01,…, 53 (7)
%c लोकेल की उचित तिथि और समय प्रतिनिधित्व। (1)
%x लोकेल की उचित तिथि प्रतिनिधित्व। (1)
%X लोकेल का उचित समय प्रतिनिधित्व। (1)
%% एक शाब्दिक '%' वर्ण। %

सुविधा के लिए C89 मानक द्वारा आवश्यक कई अतिरिक्त निर्देशों को शामिल नहीं किया गया है। ये सभी पैरामीटर आईएसओ 8601 तिथि मानों के अनुरूप हैं। ये सभी प्लेटफ़ॉर्म पर उपलब्ध नहीं हो सकते हैं जब strftime() विधि के साथ उपयोग किया जाता है । आईएसओ 8601 वर्ष और आईएसओ 8601 सप्ताह निर्देश ऊपर वर्ष और सप्ताह संख्या निर्देशों के साथ विनिमेय नहीं हैं। strptime() अपूर्ण या अस्पष्ट आईएसओ 8601 निर्देशों के साथ कॉल करने से ए बढ़ेगा ValueError

आदेश अर्थ उदाहरण टिप्पणियाँ
%G आईएसओ 8601 वर्ष शताब्दी के साथ उस वर्ष का प्रतिनिधित्व करता है जिसमें आईएसओ सप्ताह का बड़ा हिस्सा होता है ( %V )। 0001, 0002,…, 2013, 2014,…, 9998, 9999 (8)
%u आईएसओ 8601 कार्यदिवस एक दशमलव संख्या के रूप में जहां 1 सोमवार है। 1, 2,…, 7
%V आईएसओ 8601 सप्ताह सोमवार के साथ सप्ताह के पहले दिन के रूप में दशमलव संख्या के रूप में। सप्ताह 01 जनवरी 4 युक्त सप्ताह है। 01, 02,…, 53 (8)

संस्करण 3.6 में नई: %G , %u और %V जोड़ा गया था।

टिप्पणियाँ:

  1. क्योंकि प्रारूप वर्तमान स्थान पर निर्भर करता है, इसलिए आउटपुट मूल्य के बारे में धारणा बनाते समय ध्यान रखा जाना चाहिए। फ़ील्ड आदेश अलग-अलग होंगे (उदाहरण के लिए, "महीना / दिन / वर्ष" बनाम "दिन / महीना / वर्ष"), और आउटपुट में यूनिकोड वर्ण हो सकता है जो लोकेल के डिफ़ॉल्ट एन्कोडिंग का उपयोग करके एन्कोड किया गया हो (उदाहरण के लिए, यदि वर्तमान लोकेल ja_JP डिफ़ॉल्ट है एन्कोडिंग में से किसी एक हो सकता है eucJP , SJIS या utf-8 , का उपयोग locale.getlocale() वर्तमान स्थान के कूट निर्धारित करने के लिए)।
  2. strptime() विधि पूर्ण [1, 9999] रेंज में वर्ष पार्स कर सकते हैं, लेकिन साल 1000 <होना चाहिए 4 अंकों चौड़ाई को शून्य से भरे।

    संस्करण 3.2 में परिवर्तित: पिछले संस्करणों में, strftime() विधि को वर्ष = = 1900 तक ही सीमित रखा गया था।

    संस्करण 3.3 में बदला गया: संस्करण 3.2 में, strftime() विधि को वर्षों => 1000 तक ही सीमित रखा गया था।

  3. जब strptime() विधि के साथ उपयोग किया जाता है , तो %p निर्देश केवल आउटपुट घंटे फ़ील्ड को प्रभावित करता है यदि %I निर्देश का उपयोग घंटे को पार्स करने के लिए किया जाता है।
  4. time मॉड्यूल के विपरीत, मॉड्यूल datetime लीप सेकंड का समर्थन नहीं करता है।
  5. जब strptime() विधि के साथ प्रयोग किया जाता है , तो %f निर्देश दाईं ओर एक से छह अंक और शून्य पैड से स्वीकार करता है। %f सी मानक में प्रारूप वर्णों के सेट का एक विस्तार है (लेकिन अलग-अलग समय पर लागू किया गया है और इसलिए हमेशा उपलब्ध है)।
  6. एक भोली वस्तु के लिए, %z और %Z प्रारूप कोड खाली तारों द्वारा प्रतिस्थापित किए जाते हैं।

    एक जागरूक वस्तु के लिए:

    %z

    utcoffset() रूप transform HHMM [SS [.ffffff]] के एक स्ट्रिंग में तब्दील हो जाता है, जहाँ HH एक 2-अंकीय स्ट्रिंग है जो UTC ऑफसेट घंटे की संख्या देता है, MM एक 2-अंकीय स्ट्रिंग है जो UTC मिनट मिनट, SS की संख्या देता है UTC ऑफसेट सेकंड की संख्या देने वाला 2-अंकीय स्ट्रिंग है और ffffff एक 6-अंकीय स्ट्रिंग है, जो UTC ऑफ़सेट ऑफसेट की संख्या देता है। Ffffff हिस्सा तब छोड़ा जाता है जब ऑफसेट सेकंड की एक पूरी संख्या हो और ffffff और SS दोनों भाग तब छोड़ा जाता है जब ऑफसेट पूरी संख्या में होता है। उदाहरण के लिए, यदि utcoffset() रिटर्न timedelta(hours=-3, minutes=-30) , %z स्ट्रिंग के साथ बदल दिया जाता है '-0330'

    संस्करण 3.7 में परिवर्तित: UTC ऑफसेट केवल कुछ मिनटों तक सीमित नहीं है।

    संस्करण 3.7 में परिवर्तित: जब %z निर्देश strptime() विधि को प्रदान किया जाता है, तो यूटीसी ऑफ़सेट में एक विभाजक के रूप में घंटे, मिनट और सेकंड हो सकते हैं। उदाहरण के लिए, '+01:00:00' एक घंटे के ऑफसेट के रूप में पार्स किया जाएगा। इसके अलावा, प्रदान 'Z' करना समान है '+00:00'

    %Z

    यदि tzname() रिटर्न None , %Z एक खाली स्ट्रिंग द्वारा प्रतिस्थापित किया जाता है। अन्यथा %Z लौटाए गए मान से बदल दिया जाता है, जो एक स्ट्रिंग होना चाहिए।

    संस्करण 3.2 में परिवर्तित: जब विधि %z को निर्देश प्रदान किया जाता strptime() है, तो एक जागरूक datetime वस्तु का उत्पादन किया जाएगा। tzinfo परिणाम के लिए सेट हो जाएगा timezone उदाहरण।

  7. जब strptime() विधि के साथ उपयोग किया जाता है , %U और %W केवल सप्ताह के दिन और कैलेंडर वर्ष ( %Y ) निर्दिष्ट होने पर गणना में उपयोग किया जाता है ।
  8. सप्ताह के दिन और आईएसओ वर्ष ( ) एक प्रारूप स्ट्रिंग में निर्दिष्ट किए जाने पर , के समान %U और %W , %V केवल गणना में उपयोग किया जाता है । यह भी ध्यान दें कि और विनिमेय नहीं हैं। %G strptime() %G %Y

फुटनोट

[1] यदि, वह है, तो हम सापेक्षता के प्रभावों को अनदेखा करते हैं

Original text