Julia 1.0

Dates




julia

Dates

Dates मॉड्यूल Dates साथ काम करने के लिए दो प्रकार प्रदान करता है: क्रमशः Date और DateTime , दिन और मिलीसेकंड परिशुद्धता का प्रतिनिधित्व; दोनों अमूर्त TimeType उपप्रकार हैं। अलग-अलग प्रकारों के लिए प्रेरणा सरल है: कुछ ऑपरेशन बहुत सरल हैं, दोनों कोड और मानसिक तर्क के संदर्भ में, जब अधिक सटीकता की जटिलताओं से निपटा नहीं जाना है। उदाहरण के लिए, चूंकि Date प्रकार केवल एक ही तिथि (अर्थात कोई घंटे, मिनट, या सेकंड) की शुद्धता का निर्धारण करता है, समय क्षेत्र के लिए सामान्य विचार, दिन के उजाले की बचत / गर्मी का समय, और छलांग सेकंड अनावश्यक और टाल जाते हैं।

Date और DateTime दोनों मूल रूप से अपरिवर्तनीय Int64 आवरण हैं। किसी भी प्रकार का एकल UTInstant{P} क्षेत्र वास्तव में एक UTInstant{P} प्रकार है, जो कि यूटी सेकंड [1] आधार पर एक निरंतर बढ़ती मशीन समयरेखा का प्रतिनिधित्व करता है। DateTime प्रकार टाइम ज़ोन ( भोले , पायथन parlance में) के बारे में पता नहीं है, जावा 8 में एक LocalDateTime के अनुरूप। अतिरिक्त समय क्षेत्र कार्यक्षमता TimeZones.jl पैकेज के माध्यम से जोड़ा जा सकता है, जो IANA समय क्षेत्र डेटाबेस को संकलित करता है। Date और DateTime दोनों ISO 8601 मानक पर आधारित हैं, जो कि प्रोलेप्टिक ग्रेगोरियन कैलेंडर का अनुसरण करता है। एक नोट यह है कि आईएसओ 8601 मानक बीसी / बीसीई तिथियों के बारे में विशेष रूप से है। सामान्य तौर पर, बीसी / बीसीई युग के अंतिम दिन, 1-12-31 ईसा पूर्व / बीसीई, इसके बाद 1-1-1 ईस्वी / सीई था, इस प्रकार कोई भी वर्ष मौजूद नहीं है। आईएसओ मानक, हालांकि, बताता है कि 1 बीसी / बीसीई वर्ष शून्य है, इसलिए 0000-12-31 , 0000-12-31 से पहले दिन है, और वर्ष -0001 (हाँ, वर्ष के लिए नकारात्मक एक) 2 बीसी / बीसीई है , वर्ष -0002 3 ई.पू. / बीसीई है, आदि।

[1]

UT सेकंड की धारणा वास्तव में काफी मौलिक है। आम तौर पर स्वीकार किए जाने वाले समय की दो अलग-अलग धारणाएं हैं, एक पृथ्वी के भौतिक रोटेशन (एक पूर्ण रोटेशन = 1 दिन) के आधार पर, दूसरी एसआई सेकंड (एक निश्चित, निरंतर मूल्य) के आधार पर। ये मौलिक रूप से अलग हैं! इसके बारे में सोचो, एक "यूटी सेकंड", जैसा कि पृथ्वी के रोटेशन के सापेक्ष परिभाषित किया गया है, दिन के आधार पर एक अलग निरपेक्ष लंबाई हो सकती है! वैसे भी, तथ्य यह है कि Date और DateTime UT सेकंड पर आधारित हैं, एक सरलीकृत, फिर भी ईमानदार धारणा है ताकि छलांग सेकंड जैसी चीजों और उनकी सारी जटिलता से बचा जा सके। समय के इस आधार को औपचारिक रूप से UT या UT1 कहा जाता है। मूल रूप से UT पर बासिंग प्रकार का अर्थ है कि हर मिनट में 60 सेकंड हैं और हर दिन में 24 घंटे हैं और कैलेंडर तिथियों पर काम करते समय अधिक प्राकृतिक गणना होती है।

कंस्ट्रक्टर्स

Date और DateTime प्रकारों का निर्माण पूर्णांक या Period प्रकारों द्वारा, पार्सिंग द्वारा, या समायोजक के माध्यम से किया जा सकता है (बाद में उन पर):

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

julia> Date(Dates.Month(7),Dates.Year(2013))
2013-07-01

Date या DateTime पार्सिंग को DateTime स्ट्रिंग्स के उपयोग से पूरा किया जाता है। प्रारूप स्ट्रिंग्स सीमांकित या निश्चित-चौड़ाई "स्लॉट्स" को परिभाषित करने की धारणा द्वारा कार्य करते हैं, जिसमें पार्स करने के लिए एक अवधि और पाठ को Date और DateTime निर्माण के लिए स्ट्रिंग को स्वरूपित करने की अवधि शामिल होती है, Date("2015-01-01","ymd") या DateTime("20150101","yyyymmdd")

सीमांकित स्लॉट निर्दिष्ट किए जाते हैं जो परिसीमनकर्ता को यह निर्दिष्ट करते हैं कि पार्सर को दो बाद की अवधि के बीच की अपेक्षा करनी चाहिए; इसलिए "ymd" पार्सर को यह "ymd" है कि "2014-07-16" जैसे डेट स्ट्रिंग में पहले और दूसरे स्लॉट के बीच, इसे - कैरेक्टर ढूंढना चाहिए। y , m , और d अक्षर पार्सर को जानते हैं कि प्रत्येक स्लॉट में किस अवधि को पार्स करना है।

वर्णों के बीच कोई सीमांकक के साथ चौड़ाई के अनुरूप अवधि को दोहराते हुए निश्चित-चौड़ाई वाले स्लॉट निर्दिष्ट किए जाते हैं। तो "yyyymmdd" "20140716" तरह एक तारीख स्ट्रिंग के अनुरूप होगा। पार्सर एक "yyyymm" की अनुपस्थिति में एक निश्चित-चौड़ाई वाले स्लॉट को अलग करता है, जो कि एक अवधि के चरित्र से अगले "yyyymm" संक्रमण "yyyymm" नोट करता है।

टेक्स्ट-फॉर्म महीने पार्सिंग के लिए समर्थन, क्रमशः u और U अक्षर के माध्यम से, संक्षिप्त और पूर्ण-लंबाई महीने के नाम के लिए समर्थित है। डिफ़ॉल्ट रूप से, केवल अंग्रेजी महीने के नाम का समर्थन किया जाता है, इसलिए u "जन", "फरवरी", "मार", आदि से मेल खाती है और U "जनवरी", "फरवरी", "मार्च", आदि से मेल खाती है। अन्य नामों के समान => वैल्यू मैपिंग फ़ंक्शंस dayname और monthname , कस्टम monthname locale=>Dict{String,Int} मैपिंग से MONTHTOVALUEABBR और MONTHTOVALUE लिए क्रमशः और पूर्ण-नाम माह के नाम से लोड किया जा सकता है।

पार्सिंग प्रदर्शन पर एक नोट: Date(date_string,format_string) फ़ंक्शन का उपयोग करना ठीक है यदि केवल कुछ ही बार कहा जाता है। यदि पार्स करने के लिए कई समान स्वरूपित डेट स्ट्रिंग्स हैं, तो सबसे पहले Dates.DateFormat बनाने के लिए यह अधिक कुशल है, और कच्चे प्रारूप स्ट्रिंग के बजाय इसे पास करें।

julia> df = DateFormat("y-m-d");

julia> dt = Date("2015-01-01",df)
2015-01-01

julia> dt2 = Date("2015-01-02",df)
2015-01-02

आप dateformat"" स्ट्रिंग मैक्रो का भी उपयोग कर सकते हैं। यह मैक्रो DateFormat ऑब्जेक्ट को एक बार बनाता है जब मैक्रो का विस्तार होता है और एक ही DateFormat ऑब्जेक्ट का उपयोग करता है, भले ही एक कोड स्निपेट कई बार चलाया जाता है।

julia> for i = 1:10^5
           Date("2015-01-01", dateformat"y-m-d")
       end

stdlib/Dates/test/io.jl में पार्सिंग और फॉर्मेटिंग टेस्ट और उदाहरणों का एक पूरा सूट उपलब्ध है।

अवधियां / तुलना

दो Date या DateTime समय के बीच की अवधि को ज्ञात करना सीधा उनके मूल प्रतिनिधित्व को UTInstant{Day} और UTInstant{Millisecond} में दिया जाता है। Date बीच का अंतर Day की संख्या में वापस आ गया है, और Millisecond की संख्या में DateTime । इसी तरह, TimeType की तुलना अंतर्निहित मशीन इंस्टेंट की तुलना का एक सरल मामला है (जो बदले में आंतरिक Int64 मूल्यों की तुलना करता है)।

julia> dt = Date(2012,2,29)
2012-02-29

julia> dt2 = Date(2000,2,1)
2000-02-01

julia> dump(dt)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 734562

julia> dump(dt2)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 730151

julia> dt > dt2
true

julia> dt != dt2
true

julia> dt + dt2
ERROR: MethodError: no method matching +(::Date, ::Date)
[...]

julia> dt * dt2
ERROR: MethodError: no method matching *(::Date, ::Date)
[...]

julia> dt / dt2
ERROR: MethodError: no method matching /(::Date, ::Date)

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

julia> dt = DateTime(2012,2,29)
2012-02-29T00:00:00

julia> dt2 = DateTime(2000,2,1)
2000-02-01T00:00:00

julia> dt - dt2
381110400000 milliseconds

एक्सेसर फ़ंक्शंस

क्योंकि Date और DateTime प्रकारों को एकल Int64 मानों के रूप में संग्रहीत किया जाता है, तिथि भागों या फ़ील्ड को Int64 फ़ंक्शंस के माध्यम से पुनर्प्राप्त किया जा सकता है। लोअरकेस एक्सेसर्स एक पूर्णांक के रूप में फ़ील्ड लौटाते हैं:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

जबकि समरूपता इसी Period प्रकार में समान मान लौटाती है:

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

कंपाउंड विधियां प्रदान की जाती हैं, क्योंकि वे एक ही समय में कई क्षेत्रों की आवश्यकता होने पर दक्षता का एक उपाय प्रदान करते हैं:

julia> Dates.yearmonth(t)
(2014, 1)

julia> Dates.monthday(t)
(1, 31)

julia> Dates.yearmonthday(t)
(2014, 1, 31)

कोई अंतर्निहित UTInstant या पूर्णांक मान तक भी पहुँच सकता है:

julia> dump(t)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 735264

julia> t.instant
Dates.UTInstant{Day}(735264 days)

julia> Dates.value(t)
735264

क्वेरी कार्य

क्वेरी फ़ंक्शन एक TimeType बारे में कैलेंडर जानकारी प्रदान करते हैं। वे सप्ताह के दिन के बारे में जानकारी शामिल करते हैं:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

julia> Dates.dayofweekofmonth(t) # 5th Friday of January
5

वर्ष का महीना:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

साथ ही TimeType के वर्ष और तिमाही के बारे में जानकारी:

julia> Dates.isleapyear(t)
false

julia> Dates.dayofyear(t)
31

julia> Dates.quarterofyear(t)
1

julia> Dates.dayofquarter(t)
31

dayname और monthname विधियां एक वैकल्पिक locale कीवर्ड भी ले सकती हैं जिसका उपयोग अन्य भाषाओं / स्थानों के लिए वर्ष के दिन या महीने का नाम वापस करने के लिए किया जा सकता है। इन कार्यों के संस्करण भी हैं संक्षिप्त नाम dayabbr , जैसे कि dayabbr और monthabbr । पहले मैपिंग को LOCALES चर में लोड किया LOCALES है:

julia> french_months = ["janvier", "février", "mars", "avril", "mai", "juin",
                        "juillet", "août", "septembre", "octobre", "novembre", "décembre"];

julia> french_monts_abbrev = ["janv","févr","mars","avril","mai","juin",
                              "juil","août","sept","oct","nov","déc"];

julia> french_days = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"];

julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_monts_abbrev, french_days, [""]);

उपर्युक्त कार्यों का उपयोग प्रश्नों को करने के लिए किया जा सकता है:

julia> Dates.dayname(t;locale="french")
"vendredi"

julia> Dates.monthname(t;locale="french")
"janvier"

julia> Dates.monthabbr(t;locale="french")
"janv"

चूंकि दिनों के संक्षिप्त संस्करण लोड नहीं किए गए हैं, इसलिए फंक्शन dayabbr का उपयोग करने की कोशिश करेंगे।

julia> Dates.dayabbr(t;locale="french")
ERROR: BoundsError: attempt to access 1-element Array{String,1} at index [5]
Stacktrace:
[...]

समय-काल-अवधि अंकगणित

किसी भी भाषा / तारीख की रूपरेखा का उपयोग करते समय यह अच्छा अभ्यास है कि तिथि-अवधि अंकगणित से कैसे परिचित होना चाहिए क्योंकि इससे निपटने के लिए कुछ मुश्किल मुद्दे हैं (हालांकि दिन-सटीक प्रकार के लिए बहुत कम)।

Dates मॉड्यूल दृष्टिकोण Period अंकगणित करते समय जितना संभव हो उतना कम बदलने की कोशिश करने के सरल सिद्धांत का पालन करने की कोशिश करता है। इस दृष्टिकोण को अक्सर कैलेंड्रिकल अंकगणित के रूप में भी जाना जाता है या आप क्या अनुमान लगा सकते हैं यदि कोई आपसे बातचीत में उसी गणना को पूछना चाहता था। इस बारे में सभी उपद्रव क्यों? आइए एक उत्कृष्ट उदाहरण लें: 1 महीने से जनवरी 31, 2014 तक जोड़ें। क्या जवाब है? जावास्क्रिप्ट 3 मार्च (31 दिन मानता है) कहेगा। PHP 2 मार्च (मानती है कि 30 दिन) कहती है। तथ्य यह है, कोई सही उत्तर नहीं है। Dates मॉड्यूल में, यह 28 फरवरी को परिणाम देता है। यह कैसे पता चलता है? मुझे कैसिनो में क्लासिक 7-7-7 जुआ खेल के बारे में सोचना पसंद है।

अब जरा सोचिए कि 7-7-7 के बजाय स्लॉट्स इयर-मंथ-डे हैं, या हमारे उदाहरण में, 2014-01-31। जब आप इस तारीख में 1 महीना जोड़ने के लिए कहते हैं, तो महीने का स्लॉट बढ़ जाता है, इसलिए अब हमारे पास 2014-02-31 है। फिर उस दिन की संख्या की जाँच की जाती है यदि यह नए महीने के अंतिम वैध दिन से अधिक है; यदि यह (ऊपर के मामले में) है, तो दिन की संख्या अंतिम वैध दिन (28) तक समायोजित हो जाती है। इस दृष्टिकोण के साथ क्या प्रभाव हैं? आगे बढ़ें और हमारी तिथि, 2014-02-28 + Month(1) == 2014-03-28 एक और महीना जोड़ें। क्या? क्या आप मार्च के अंतिम दिन की उम्मीद कर रहे थे? नहीं, क्षमा करें, 7-7-7 स्लॉट याद रखें। जहां तक ​​संभव हो कुछ स्लॉट्स बदलने जा रहे हैं, इसलिए हम पहले महीने के स्लॉट को 1, 2014-03-28, और बूम के अनुसार बढ़ाते हैं, हम कर रहे हैं क्योंकि यह एक वैध तारीख है। दूसरी ओर, यदि हमें अपनी मूल तिथि, 2014-01-31 में 2 महीने जोड़ने थे, तो हम उम्मीद के मुताबिक 2014-03-31 तक समाप्त हो गए। इस दृष्टिकोण का अन्य असर तब होता है, जब विशिष्ट ऑर्डरिंग को मजबूर किया जाता है (यानी अलग-अलग ऑर्डर में चीजों को जोड़ने से अलग-अलग परिणाम प्राप्त होते हैं)। उदाहरण के लिए:

julia> (Date(2014,1,29)+Dates.Day(1)) + Dates.Month(1)
2014-02-28

julia> (Date(2014,1,29)+Dates.Month(1)) + Dates.Day(1)
2014-03-01

वहाँ क्या हो रहा है? पहली पंक्ति में, हम 1 दिन को 29 जनवरी से जोड़ रहे हैं, जिसका परिणाम 2014-01-30 है; फिर हम 1 महीना जोड़ते हैं, इसलिए हमें 2014-02-30 मिलता है, जो फिर 2014-02-28 तक समायोजित हो जाता है। दूसरे उदाहरण में, हम 1 महीना पहले जोड़ते हैं, जहां हमें 2014-02-29 मिलता है, जो 2014-02-28 तक समायोजित हो जाता है, और फिर 1 दिन जोड़ते हैं, जिसका परिणाम 2014-03-01 है। एक डिजाइन सिद्धांत जो इस मामले में मदद करता है, वह यह है कि, कई पीरियड्स की उपस्थिति में, ऑपरेशंस को पीरियड्स के प्रकारों के अनुसार ऑर्डर किया जाएगा, न कि उनके मूल्य या स्थिति संबंधी ऑर्डर को; इसका अर्थ है कि Year को हमेशा पहले जोड़ा जाएगा, फिर Month , फिर Week आदि। इसलिए निम्नलिखित में सहानुभूति और न्यायपूर्ण कार्य होते हैं:

julia> Date(2014,1,29) + Dates.Day(1) + Dates.Month(1)
2014-03-01

julia> Date(2014,1,29) + Dates.Month(1) + Dates.Day(1)
2014-03-01

मुश्किल? शायद। क्या करने के लिए एक निर्दोष Dates उपयोगकर्ता है? लब्बोलुआब यह है कि स्पष्ट रूप से एक निश्चित सहानुभूति के लिए मजबूर करना है, जब महीनों के साथ काम करते हैं, तो कुछ अप्रत्याशित परिणाम हो सकते हैं, लेकिन अन्यथा, सब कुछ उम्मीद के मुताबिक काम करना चाहिए। शुक्र है, यह बहुत अधिक है जब यूटी में समय के साथ काम करते हुए तिथि-अवधि अंकगणित में विषम मामलों की सीमा होती है (दिन की बचत, छलांग सेकंड आदि से निपटने के "खुशियों से बचने")।

एक बोनस के रूप में, सभी अवधि अंकगणितीय वस्तुएं श्रेणियों के साथ सीधे काम करती हैं:

julia> dr = Date(2014,1,29):Day(1):Date(2014,2,3)
2014-01-29:1 day:2014-02-03

julia> collect(dr)
6-element Array{Date,1}:
 2014-01-29
 2014-01-30
 2014-01-31
 2014-02-01
 2014-02-02
 2014-02-03

julia> dr = Date(2014,1,29):Dates.Month(1):Date(2014,07,29)
2014-01-29:1 month:2014-07-29

julia> collect(dr)
7-element Array{Date,1}:
 2014-01-29
 2014-02-28
 2014-03-29
 2014-04-29
 2014-05-29
 2014-06-29
 2014-07-29

समायोजक कार्य

तिथि-अवधि के अंकगणित के रूप में सुविधाजनक है, अक्सर तारीखों पर आवश्यक गणनाओं की संख्या निश्चित अवधि के बजाय एक कैलेंडर या लौकिक प्रकृति पर होती है। छुट्टियां एक आदर्श उदाहरण हैं; "मेमोरियल डे = मई के अंतिम सोमवार", या "धन्यवाद = नवंबर के चौथे गुरुवार" जैसे अधिकांश नियमों का पालन करें। इस प्रकार के लौकिक भाव कैलेंडर के सापेक्ष नियमों से संबंधित होते हैं, जैसे महीने का पहला या अंतिम, अगले मंगलवार, या पहले और तीसरे दिन, आदि।

Dates मॉड्यूल एडजस्टेबल एपीआई को कई सुविधाजनक तरीकों के माध्यम से प्रदान करता है जो बस और आसानी से लौकिक नियमों को व्यक्त करने में सहायता करते हैं। समायोजक विधियों का पहला समूह पहले और अंतिम सप्ताह, महीनों, तिमाहियों और वर्षों से निपटता है। वे प्रत्येक इनपुट के रूप में एक सिंगल TimeType लेते हैं और इनपुट के सापेक्ष वांछित अवधि के पहले या अंतिम पर वापस लौट जाते हैं।

julia> Dates.firstdayofweek(Date(2014,7,16)) # Adjusts the input to the Monday of the input's week
2014-07-14

julia> Dates.lastdayofmonth(Date(2014,7,16)) # Adjusts to the last day of the input's month
2014-07-31

julia> Dates.lastdayofquarter(Date(2014,7,16)) # Adjusts to the last day of the input's quarter
2014-09-30

अगले दो उच्च-क्रम के तरीके, tonext और toprev , एक शुरुआती TimeType के साथ, पहले तर्क के रूप में एक DateFunction लेकर लौकिक अभिव्यक्तियों के साथ काम करना सामान्य करते हैं। DateFunction केवल एक फ़ंक्शन है, आमतौर पर अनाम, जो इनपुट के रूप में एक सिंगल TimeType लेता है और एक TimeType लौटाता है, एक संतुष्ट समायोजन मानदंड का संकेत देता है। उदाहरण के लिए:

julia> istuesday = x->Dates.dayofweek(x) == Dates.Tuesday; # Returns true if the day of the week of x is Tuesday

julia> Dates.tonext(istuesday, Date(2014,7,13)) # 2014-07-13 is a Sunday
2014-07-15

julia> Dates.tonext(Date(2014,7,13), Dates.Tuesday) # Convenience method provided for day of the week adjustments
2014-07-15

यह अधिक जटिल लौकिक अभिव्यक्तियों के लिए डू-ब्लॉक सिंटैक्स के साथ उपयोगी है:

julia> Dates.tonext(Date(2014,7,13)) do x
           # Return true on the 4th Thursday of November (Thanksgiving)
           Dates.dayofweek(x) == Dates.Thursday &&
           Dates.dayofweekofmonth(x) == 4 &&
           Dates.month(x) == Dates.November
       end
2014-11-27

Base.filter विधि का उपयोग किसी निर्दिष्ट सीमा में सभी मान्य तिथियों / क्षणों को प्राप्त करने के लिए किया जा सकता है:

# Pittsburgh street cleaning; Every 2nd Tuesday from April to November
# Date range from January 1st, 2014 to January 1st, 2015
julia> dr = Dates.Date(2014):Day(1):Dates.Date(2015);

julia> filter(dr) do x
           Dates.dayofweek(x) == Dates.Tue &&
           Dates.April <= Dates.month(x) <= Dates.Nov &&
           Dates.dayofweekofmonth(x) == 2
       end
8-element Array{Date,1}:
 2014-04-08
 2014-05-13
 2014-06-10
 2014-07-08
 2014-08-12
 2014-09-09
 2014-10-14
 2014-11-11

अतिरिक्त उदाहरण और परीक्षण stdlib/Dates/test/adjusters.jl . stdlib/Dates/test/adjusters.jl में उपलब्ध हैं।

अवधि प्रकार

पीरियड्स कभी-कभी समय की अनियमित अवधियों के असतत दृष्टिकोण का मानवीय दृष्टिकोण है। 1 महीने पर विचार करें; यह वर्ष और महीने के संदर्भ के आधार पर, 28 दिनों, 29, 30 या 31 के मूल्य का प्रतिनिधित्व कर सकता है। या एक वर्ष लीप वर्ष के मामले में 365 या 366 दिनों का प्रतिनिधित्व कर सकता है। Period प्रकार सरल Int64 आवरण हैं और किसी भी Int64 परिवर्तनीय प्रकार, अर्थात Year(1) या Month(3.0) को लपेटकर निर्मित होते हैं। एक ही प्रकार की Period के बीच अंकगणित पूर्णांक की तरह व्यवहार करता है, और सीमित Period-Real अंकगणित उपलब्ध है।

julia> y1 = Dates.Year(1)
1 year

julia> y2 = Dates.Year(2)
2 years

julia> y3 = Dates.Year(10)
10 years

julia> y1 + y2
3 years

julia> div(y3,y2)
5

julia> y3 - y2
8 years

julia> y3 % y2
0 years

julia> div(y3,3) # mirrors integer division
3 years

गोलाई

Date और DateTime मानों को एक निर्दिष्ट रिज़ॉल्यूशन (जैसे, 1 महीने या 15 मिनट) पर floor , floor , या round :

julia> floor(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:45:00

julia> round(DateTime(2016, 8, 6, 20, 15), Dates.Day)
2016-08-07T00:00:00

संख्यात्मक round विधि के विपरीत, जो डिफ़ॉल्ट रूप से सम संख्या की ओर संबंध तोड़ता है, TimeType round विधि RoundNearestTiesUp राउंडिंग मोड का उपयोग करता है। (यह अनुमान लगाना मुश्किल है कि निकटतम " TimeType " के लिए कौन से ब्रेकिंग संबंध हैं। TimeType करेगा।) उपलब्ध TimeType s पर आगे का विवरण एपीआई संदर्भ में पाया जा सकता है।

राउंडिंग को आम तौर पर अपेक्षा के अनुसार व्यवहार करना चाहिए, लेकिन कुछ मामले हैं जिनमें अपेक्षित व्यवहार स्पष्ट नहीं है।

गोलाई युग

कई मामलों में, गोलाई के लिए निर्दिष्ट संकल्प (जैसे, Dates.Second(30) ) समान रूप से अगले सबसे बड़ी अवधि (इस मामले में, Dates.Minute(1) ) में Dates.Minute(1) । लेकिन जिन मामलों में यह सच नहीं है उन पर गोल व्यवहार करना भ्रम पैदा कर सकता है। निकटतम 10 घंटों के लिए DateTime करने का अपेक्षित परिणाम क्या है?

julia> round(DateTime(2016, 7, 17, 11, 55), Dates.Hour(10))
2016-07-17T12:00:00

यह भ्रामक लग सकता है, यह देखते हुए कि घंटा (12) 10 से विभाज्य नहीं है। इसका कारण यह है कि 2016-07-17T12:00:00 को चुना गया था कि यह 0000-01-01T00:00:00 बाद 0000-01-01T00:00:00 घंटे है। 17,676,660 10 से विभाज्य है।

जैसा कि जूलिया Date और DateTime मान आईएसओ 8601 मानक के अनुसार दर्शाए जाते हैं, 0000-01-01T00:00:00 को आधार (या "राउंडिंग एपोक") के रूप में चुना गया था, जिसमें से दिनों की गिनती शुरू करने के लिए (और राउंडिंग में उपयोग किए गए मिलीसेकंड) गणना। (ध्यान दें कि यह जटिया के आंतरिक प्रतिनिधित्व से थोड़ा भिन्न होता है 0000-01-01T00:00:00 डाई संकेतन का उपयोग करके; लेकिन चूंकि आईएसओ 8601 मानक अंतिम उपयोगकर्ता के लिए सबसे अधिक दिखाई देता है, 0000-01-01T00:00:00 को इसके बजाय गोल युग के रूप में चुना गया था 0000-12-31T00:00:00 भ्रम को कम करने के लिए आंतरिक रूप से उपयोग किया जाता है।)

0000-01-01T00:00:00 का उपयोग करने का एकमात्र अपवाद 0000-01-01T00:00:00 क्योंकि गोलाई का युग तब होता है जब सप्ताह के लिए गोलाई होती है। निकटतम सप्ताह के लिए गोलाई हमेशा एक सोमवार (सप्ताह के पहले दिन आईएसओ 8601 द्वारा निर्दिष्ट) वापस आ जाएगी। इस कारण से, हम 0000-01-03T00:00:00 उपयोग 0000-01-03T00:00:00 (वर्ष 0000 के पहले सप्ताह का पहला दिन, जैसा कि आईएसओ 8601 द्वारा परिभाषित किया गया है) आधार के रूप में कई हफ्तों तक 0000-01-03T00:00:00

यहां एक संबंधित मामला है जिसमें अपेक्षित व्यवहार स्पष्ट रूप से स्पष्ट नहीं है: क्या होता है जब हम निकटतम P(2) के पास होते हैं, जहां P एक Period प्रकार है? कुछ मामलों में (विशेषकर, जब P <: Dates.TimePeriod ) का उत्तर स्पष्ट है:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Hour(2))
2016-07-17T08:00:00

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Minute(2))
2016-07-17T08:56:00

यह स्पष्ट प्रतीत होता है, क्योंकि इनमें से प्रत्येक अवधि दो अभी भी अगले बड़े क्रम अवधि में समान रूप से विभाजित होती है। लेकिन दो महीने के मामले में (जो अभी भी एक वर्ष में समान रूप से विभाजित होता है), जवाब आश्चर्यजनक हो सकता है:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Month(2))
2016-07-01T00:00:00

जुलाई में पहले दिन के लिए राउंड क्यों, भले ही यह 7 महीने (एक विषम संख्या) है? कुंजी यह है कि महीने 1-अनुक्रमित होते हैं (पहला महीना 1 सौंपा गया है), घंटे, मिनट, सेकंड और मिलीसेकंड के विपरीत (जिनमें से पहले को 0 असाइन किया गया है)।

इसका मतलब यह है कि DateTime को कई सेकंड, मिनट, घंटे, या वर्षों में राउंड करना (क्योंकि ISO 8601 विनिर्देशन में एक वर्ष शून्य भी शामिल है) के परिणामस्वरूप DateTime उस क्षेत्र में एक समान मूल्य के साथ होगा, जबकि DateTime को एक बार में भी कई महीनों के परिणामस्वरूप महीनों का क्षेत्र एक विषम मान होगा। क्योंकि दोनों महीनों और वर्षों में अनियमित दिनों की संख्या शामिल हो सकती है, चाहे दिन के एक दिन की भी परिक्रमा करना परिणामी दिनों में एक समान मूल्य होगा।

Dates मॉड्यूल से निर्यात की गई विधियों के बारे में अतिरिक्त जानकारी के लिए एपीआई संदर्भ देखें।

एपीआई संदर्भ

दिनांक और समय के प्रकार

Dates.Period प्रकार

Period
Year
Month
Week
Day
Hour
Minute
Second
Millisecond
Microsecond
Nanosecond

Period प्रकार असतत का प्रतिनिधित्व करते हैं, समय का मानव प्रतिनिधित्व करते हैं।

source

Dates.CompoundPeriod प्रकार

CompoundPeriod

एक CompoundPeriod समय अवधि को व्यक्त करने के लिए उपयोगी है जो एक निश्चित अवधि के छोटे अवधि नहीं हैं। उदाहरण के लिए, "एक वर्ष और एक दिन" निश्चित दिनों की संख्या नहीं है, लेकिन एक CompoundPeriod का उपयोग करके व्यक्त किया जा सकता है। वास्तव में, एक CompoundPeriod स्वचालित रूप से विभिन्न अवधि प्रकारों के अलावा उत्पन्न होता है, जैसे Year(1) + Day(1) एक CompoundPeriod परिणाम उत्पन्न करता है।

source

Dates.Instant टाइप

Instant

Instant प्रकार पूर्णांक-आधारित का प्रतिनिधित्व करते हैं, समय के मशीन निरूपण के रूप में एक युग से शुरू होने वाली समयरेखा।

source

Dates.UTInstant प्रकार

UTInstant{T}

UTInstant UT समय (1 दिन = पृथ्वी की एक परिक्रमा) के आधार पर मशीन टाइमलाइन का प्रतिनिधित्व करता है। T एक Period पैरामीटर है जो कि तात्कालिक के संकल्प या सटीकता को इंगित करता है।

source

Dates.TimeType प्रकार

TimeType

TimeType टाइप प्रकार Instant मशीन के उदाहरणों को मशीन के मानव अभ्यावेदन को तत्काल प्रदान करने के लिए लपेटते हैं। Time , DateTime और Date TimeType उपप्रकार हैं।

source

Dates.DateTime प्रकार

DateTime

UTInstant{Millisecond} एक UTInstant{Millisecond} लपेटता है और इसे प्रोलेप्टिक ग्रेगोरियन कैलेंडर के अनुसार व्याख्या करता है।

source

Dates.Date प्रकार

Date

Date एक UTInstant{Day} लपेटता है और इसे प्रलेपिटिक ग्रेगोरियन कैलेंडर के अनुसार व्याख्या करता है।

source

Dates.Time प्रकार

Time

Time एक Nanosecond लपेटता है और 24-घंटे के दिन में एक विशिष्ट क्षण का प्रतिनिधित्व करता है।

source

तिथियां कार्य

Dates.DateTime विधि

DateTime(y, [m, d, h, mi, s, ms]) -> DateTime

भागों द्वारा DateTime टाइप करें। तर्क Int64 लिए परिवर्तनीय होना चाहिए।

source

Dates.DateTime विधि

DateTime(periods::Period...) -> DateTime

एक Period टाइप भागों द्वारा DateTime प्रकार का निर्माण करें। तर्क किसी भी क्रम में हो सकते हैं। Dates.default(period) भागों को प्रदान नहीं किया गया Dates.default(period) के मान के लिए डिफ़ॉल्ट होगा।

source

Dates.DateTime विधि

DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), limit=10000) -> DateTime

समायोजक एपीआई के माध्यम से एक DateTime बनाएं। शुरुआती बिंदु का निर्माण प्रदान किए गए y, m, d... तर्कों से किया जाएगा, और तब तक समायोजित किया जाएगा जब तक कि f::Function true । समायोजन में कदम का आकार मैन्युअल रूप से step कीवर्ड के माध्यम से प्रदान किया जा सकता है। limit अधिकतम संख्या के पुनरावृत्तियों को एक limit प्रदान करती है समायोजन एपीआई एक त्रुटि को फेंकने से पहले पीछा करेगा (इस मामले में कि f::Function कभी संतुष्ट नहीं है)।

उदाहरण

julia> DateTime(dt -> Dates.second(dt) == 40, 2010, 10, 20, 10; step = Dates.Second(1))
2010-10-20T10:00:40

julia> DateTime(dt -> Dates.hour(dt) == 20, 2010, 10, 20, 10; step = Dates.Hour(1), limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]
source

Dates.DateTime विधि

DateTime(dt::Date) -> DateTime

Date को DateTime परिवर्तित करें। नए DateTime घंटे, मिनट, सेकंड और मिलीसेकंड भागों को शून्य माना जाता है।

source

Dates.DateTime विधि

DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime

DateTime स्ट्रिंग समय format स्ट्रिंग में दिए गए पैटर्न का पालन करके एक DateTime निर्माण करें।

यह विधि हर बार जब यह कहा जाता है एक DateFormat ऑब्जेक्ट बनाता है। यदि आप एक ही प्रारूप के कई दिनांक समय स्ट्रिंग को पार्स कर रहे हैं, तो एक बार Dates.DateFormat ऑब्जेक्ट बनाने और इसके बजाय दूसरे तर्क के रूप में उपयोग करने पर विचार करें।

source

Dates.format फ़ंक्शन

format(io::IO, tok::AbstractDateToken, dt::TimeType, locale)

dt से टोकन टोकन को प्रारूपित करें और इसे io लिखें। प्रारूपण locale पर आधारित हो सकता है।

AbstractDateToken सभी उपप्रकारों को इस विधि को परिभाषित करना चाहिए ताकि DateFormat उस टोकन के अनुसार दिनांक / DateTime ऑब्जेक्ट मुद्रित करने में सक्षम हो।

source

Dates.DateFormat टाइप

DateFormat(format::AbstractString, locale="english") -> DateFormat

दिनांक स्वरूपित ऑब्जेक्ट का निर्माण करें जिसका उपयोग दिनांक स्ट्रिंग को पार्स करने या स्ट्रिंग के रूप में दिनांक ऑब्जेक्ट को फ़ॉर्मेट करने के लिए किया जा सकता है। format स्ट्रिंग का निर्माण करने के लिए निम्नलिखित वर्ण कोड का उपयोग किया जा सकता है:

कोड माचिस टिप्पणी
y 1996, 96 1996 का रिटर्न वर्ष, 0096
Y 1996, 96 1996 का रिटर्न वर्ष, 0096। y बराबर है
m १, ०१ 1 या 2-अंकीय महीनों से मेल खाता है
u जनवरी locale कीवर्ड के अनुसार संक्षिप्त महीनों से मेल खाता है
U जनवरी locale कीवर्ड के अनुसार पूरे महीने के नाम मेल locale
d १, ०१ 1 या 2-अंकीय दिनों से मेल खाता है
H 00 घंटों मेल खाता है
M 00 मेल खाता है
S 00 सेकंड से मेल खाता है
s .500 मिलीसेकंड से मेल खाता है
e सोम, मंगल सप्ताह के संक्षिप्त दिनों से मेल खाता है
E सोमवार सप्ताह के पूर्ण नाम दिनों से मेल खाता है
yyyymmdd 19960101 निश्चित-चौड़ाई वर्ष, माह और दिन से मेल खाता है

ऊपर सूचीबद्ध वर्ण आमतौर पर तारीख और समय स्लॉट के बीच सीमांकक के रूप में नहीं माने जाते हैं। उदाहरण के लिए "1996-01-15T00: 00: 00.0" के एक dt स्ट्रिंग में "ym-dTH: M: Ss" जैसा एक format स्ट्रिंग होगा। यदि आपको एक कोड कैरेक्टर को एक सीमांकक के रूप में उपयोग करने की आवश्यकता है तो आप बैकस्लैश का उपयोग करके इससे बच सकते हैं दिनांक "1995y01m" में प्रारूप "y \ ym \ m" होगा।

DateFormat ऑब्जेक्ट बनाना महंगा है। जब भी संभव हो, इसे एक बार बनाएं और इसे कई बार उपयोग करें या dateformat"" स्ट्रिंग स्ट्रिंग को dateformat"" । इस मैक्रो का उपयोग मैक्रो विस्तार समय में एक बार DateFormat ऑब्जेक्ट बनाता है और बाद में इसका पुन: उपयोग करता है। @dateformat_str देखें।

DateTime और DateTime तार को लिखने के लिए DateFormat ऑब्जेक्ट का उपयोग करने के लिए DateTime और format देखें।

source

[email protected]_str मैक्रो

dateformat"Y-m-d H:M:S"

Dates.DateFormat ऑब्जेक्ट बनाएँ। DateFormat("Ymd H:M:S") समान DateFormat("Ymd H:M:S") लेकिन मैक्रो विस्तार के दौरान एक बार DateFormat ऑब्जेक्ट बनाता है।

प्रारूप निर्दिष्टकर्ताओं के बारे में विवरण के लिए Dates.DateFormat देखें।

source

Dates.DateTime विधि

DateTime(dt::AbstractString, df::DateFormat) -> DateTime

Dates.DateFormat ऑब्जेक्ट में दिए गए पैटर्न का अनुसरण करते हुए dt डेट टाइम स्ट्रिंग को पार्स करके DateTime निर्माण करें। DateTime(::AbstractString, ::AbstractString) समान DateTime(::AbstractString, ::AbstractString) लेकिन अधिक कुशल जब बार-बार एक पूर्व-निर्मित DateFormat ऑब्जेक्ट के साथ समान रूप से स्वरूपित दिनांक समय तार को पार्स करता है।

source

Dates.Date विधि

Date(y, [m, d]) -> Date

भागों द्वारा Date प्रकार बनाएँ। तर्क Int64 लिए परिवर्तनीय होना चाहिए।

source

Dates.Date विधि

Date(period::Period...) -> Date

Period प्रकार भागों द्वारा Date प्रकार का निर्माण करें। तर्क किसी भी क्रम में हो सकते हैं। प्रदान नहीं किए गए Date भाग Dates.default(period) के मान के लिए डिफ़ॉल्ट होंगे।

source

Dates.Date विधि

Date(f::Function, y[, m, d]; step=Day(1), limit=10000) -> Date

समायोजक एपीआई के माध्यम से एक Date बनाएँ। शुरुआती बिंदु का निर्माण प्रदान किए गए y, m, d तर्कों से किया जाएगा, और तब तक समायोजित किया जाएगा, जब तक कि f::Function true । समायोजन में कदम का आकार मैन्युअल रूप से step कीवर्ड के माध्यम से प्रदान किया जा सकता है। limit अधिकतम संख्या पुनरावृत्तियों को एक limit प्रदान करती है समायोजन एपीआई एक त्रुटि को फेंकने से पहले पीछा करेगा (यह देखते हुए कि f::Function कभी संतुष्ट नहीं है)।

उदाहरण

julia> Date(date -> Dates.week(date) == 20, 2010, 01, 01)
2010-05-17

julia> Date(date -> Dates.year(date) == 2010, 2000, 01, 01)
2010-01-01

julia> Date(date -> Dates.month(date) == 10, 2000, 01, 01; limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]
source

Dates.Date विधि

Date(dt::DateTime) -> Date

किसी DateTime को DateTime कनवर्ट करें। DateTime घंटे, मिनट, दूसरे और मिलीसेकंड भागों को काट दिया जाता है, इसलिए निर्माण में केवल वर्ष, माह और दिन भागों का उपयोग किया जाता है।

source

Dates.Date विधि

Date(d::AbstractString, format::AbstractString; locale="english") -> Date

format स्ट्रिंग में दिए गए पैटर्न के बाद d दिनांक स्ट्रिंग को पार्स करके Date निर्माण करें।

यह विधि हर बार जब यह कहा जाता है एक DateFormat ऑब्जेक्ट बनाता है। यदि आप एक ही प्रारूप के कई तारीखों को पार्स कर रहे हैं, तो एक बार Dates.DateFormat ऑब्जेक्ट बनाने और उसके बजाय दूसरे तर्क के रूप में उपयोग करने पर विचार करें।

source

Dates.Date विधि

Date(d::AbstractString, df::DateFormat) -> Date

DateFormat ऑब्जेक्ट df का उपयोग करते हुए दिनांक स्ट्रिंग d से दिनांक पार्स करें।

source

Dates.Time विधि

Time(h, [mi, s, ms, us, ns]) -> Time

भागों द्वारा एक Time प्रकार का निर्माण। तर्क Int64 लिए परिवर्तनीय होना चाहिए।

source

Dates.Time विधि

Time(period::TimePeriod...) -> Time

Period टाइप पार्ट्स के द्वारा Time टाइप का निर्माण करें। तर्क किसी भी क्रम में हो सकते हैं। प्रदान नहीं किए गए Time भाग Dates.default(period) के मान के लिए डिफ़ॉल्ट होंगे।

source

Dates.Time विधि

Time(f::Function, h, mi=0; step::Period=Second(1), limit::Int=10000)
Time(f::Function, h, mi, s; step::Period=Millisecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms; step::Period=Microsecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms, us; step::Period=Nanosecond(1), limit::Int=10000)

समायोजक एपीआई के माध्यम से एक Time बनाएँ। शुरुआती बिंदु का निर्माण प्रदान किए गए h, mi, s, ms, us करेंगे, और तब तक समायोजित किया जाएगा, जब तक कि f::Function रिटर्न true । समायोजन में कदम का आकार मैन्युअल रूप से step कीवर्ड के माध्यम से प्रदान किया जा सकता है। limit अधिकतम संख्या के पुनरावृत्तियों को एक limit प्रदान करती है समायोजन एपीआई एक त्रुटि को फेंकने से पहले पीछा करेगा (इस मामले में कि f::Function कभी संतुष्ट नहीं है)। ध्यान दें कि डिफ़ॉल्ट कदम दिए गए तर्कों के लिए अधिक सटीक अनुमति देने के लिए समायोजित करेगा; यानी अगर घंटे, मिनट और दूसरी दलीलें दी जाती हैं, तो Second(1) बजाय डिफ़ॉल्ट कदम Millisecond(1) होगा।

उदाहरण

julia> Dates.Time(t -> Dates.minute(t) == 30, 20)
20:30:00

julia> Dates.Time(t -> Dates.minute(t) == 0, 20)
20:00:00

julia> Dates.Time(t -> Dates.hour(t) == 10, 3; limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]
source

Dates.Time विधि

Time(dt::DateTime) -> Time

DateTime कनवर्ट करें। नया Time बनाने के लिए DateTime घंटे, मिनट, सेकंड और मिलीसेकंड भागों का उपयोग किया जाता है। माइक्रोसेकंड और नैनोसेकंड डिफ़ॉल्ट रूप से शून्य हैं।

source

Dates.now विधि

now() -> DateTime

सिस्टम टाइमज़ोन लोकेल सहित उपयोगकर्ता के सिस्टम समय के अनुरूप DateTime लौटाएं।

source

Dates.now विधि

now(::Type{UTC}) -> DateTime

UTC / GMT के रूप में उपयोगकर्ता के सिस्टम समय के अनुरूप DateTime लौटाएँ।

source

Base.eps फ़ंक्शन

eps(::DateTime) -> Millisecond
eps(::Date) -> Day
eps(::Time) -> Nanosecond

DateTime मानों के लिए Millisecond(1) , DateTime मानों के लिए Day(1) , और Time मानों के लिए Nanosecond(1) लौटाता है।

source

एक्सेसर फ़ंक्शंस

Dates.year

year(dt::TimeType) -> Int64

एक Int64 रूप में एक Date या DateTime का वर्ष।

source

Dates.month फ़ंक्शन

month(dt::TimeType) -> Int64

एक Int64 रूप में एक Date या DateTime का महीना।

source

Dates.week फ़ंक्शन

week(dt::TimeType) -> Int64

Int64 रूप में Date या DateTime की ISO सप्ताह दिनांक लौटाएँ। ध्यान दें कि एक वर्ष का पहला सप्ताह वह सप्ताह होता है जिसमें वर्ष का पहला गुरुवार होता है, जिसके परिणामस्वरूप दिनांक 4 जनवरी से पहले पिछले वर्ष के अंतिम सप्ताह में हो सकते हैं। उदाहरण के लिए, week(Date(2005, 1, 1)) 2004 का 53 वां सप्ताह है।

उदाहरण

julia> Dates.week(Date(1989, 6, 22))
25

julia> Dates.week(Date(2005, 1, 1))
53

julia> Dates.week(Date(2004, 12, 31))
53
source

Dates.day

day(dt::TimeType) -> Int64

एक Int64 रूप में एक Date या DateTime के महीने का दिन।

source

Dates.hour

hour(dt::DateTime) -> Int64

एक Int64 रूप में एक DateTime के दिन का DateTime

source
hour(t::Time) -> Int64

एक Int64 रूप में एक Time

source

Dates.minute

minute(dt::DateTime) -> Int64

एक Int64 रूप में एक DateTime का मिनट।

source
minute(t::Time) -> Int64

एक Int64 रूप में एक Time का मिनट।

source

Dates.second फ़ंक्शन

second(dt::DateTime) -> Int64

एक Int64 रूप में एक DateTime का दूसरा।

source
second(t::Time) -> Int64

एक के Time रूप में दूसरा Int64

source

Dates.millisecond समारोह

millisecond(dt::DateTime) -> Int64

एक के DateTime रूप में मिलीसेकंड ए Int64

source
millisecond(t::Time) -> Int64

एक के Time रूप में मिलीसेकंड ए Int64

source

Dates.microsecond समारोह

microsecond(t::Time) -> Int64

एक के Time रूप में microsecond a Int64

source

Dates.nanosecond समारोह

nanosecond(t::Time) -> Int64

एक के Time रूप में नैनोसेकंड ए Int64

source

Dates.Year तरीका

Year(v)

Year दिए गए v मूल्य के साथ एक वस्तु का निर्माण । इनपुट दोषरहित रूप से परिवर्तनीय होना चाहिए a Int64

source

Dates.Month तरीका

Month(v)

Month दिए गए v मूल्य के साथ एक वस्तु का निर्माण । इनपुट दोषरहित रूप से परिवर्तनीय होना चाहिए a Int64

source

Dates.Week तरीका

Week(v)

Week दिए गए v मूल्य के साथ एक वस्तु का निर्माण । इनपुट दोषरहित रूप से परिवर्तनीय होना चाहिए a Int64

source

Dates.Day तरीका

Day(v)

Day दिए गए v मूल्य के साथ एक वस्तु का निर्माण । इनपुट दोषरहित रूप से परिवर्तनीय होना चाहिए a Int64

source

Dates.Hour तरीका

Hour(dt::DateTime) -> Hour

एक के रूप में एक DateTime का घंटा हिस्सा Hour

source

Dates.Minute तरीका

Minute(dt::DateTime) -> Minute

एक के रूप में एक DateTime का मिनट हिस्सा Minute

source

Dates.Second तरीका

Second(dt::DateTime) -> Second

डेटाइम के दूसरे भाग के रूप में Second

source

Dates.Millisecond तरीका

Millisecond(dt::DateTime) -> Millisecond

एक के रूप में एक DateTime का मिलीसेकंड हिस्सा Millisecond

source

Dates.Microsecond तरीका

Microsecond(dt::Time) -> Microsecond

एक समय के रूप में microsecond हिस्सा ए Microsecond

source

Dates.Nanosecond तरीका

Nanosecond(dt::Time) -> Nanosecond

एक के रूप में एक समय का nanosecond हिस्सा Nanosecond

source

Dates.yearmonth समारोह

yearmonth(dt::TimeType) -> (Int64, Int64)

इसके साथ ही Date या के वर्ष और महीने के हिस्से वापस करें DateTime

source

Dates.monthday समारोह

monthday(dt::TimeType) -> (Int64, Int64)

इसके साथ ही Date या के महीने और दिन के हिस्से वापस करें DateTime

source

Dates.yearmonthday समारोह

yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)

इसके साथ ही एक के वर्ष, माह और दिन भागों वापसी Date या DateTime

source

क्वेरी कार्य

Dates.dayname समारोह

dayname(dt::TimeType; locale="english") -> String

के सप्ताह के दिन के लिए इसी पूरा दिन नाम वापस Date या DateTime दिए गए में locale

उदाहरण

julia> Dates.dayname(Date("2000-01-01"))
"Saturday"
source

Dates.dayabbr समारोह

dayabbr(dt::TimeType; locale="english") -> String

संक्षिप्त नाम के सप्ताह के दिन के लिए इसी लौटें Date या DateTime दिए गए में locale

उदाहरण

julia> Dates.dayabbr(Date("2000-01-01"))
"Sat"
source

Dates.dayofweek समारोह

dayofweek(dt::TimeType) -> Int64

एक के रूप में सप्ताह के दिन लौटें Int64 के साथ 1 = Monday, 2 = Tuesday, etc.

उदाहरण

julia> Dates.dayofweek(Date("2000-01-01"))
6
source

Dates.dayofmonth समारोह

dayofmonth(dt::TimeType) -> Int64

महीने के दिन Date या DateTime एक के रूप में Int64

source

Dates.dayofweekofmonth समारोह

dayofweekofmonth(dt::TimeType) -> Int

सप्ताह के दिन के लिए dt , यह किस dt महीने में है। इसलिए यदि सप्ताह का दिन dt सोमवार है, तो 1 = First Monday of the month, 2 = Second Monday of the month, etc. 1: 5 की सीमा में।

उदाहरण

julia> Dates.dayofweekofmonth(Date("2000-02-01"))
1

julia> Dates.dayofweekofmonth(Date("2000-02-08"))
2

julia> Dates.dayofweekofmonth(Date("2000-02-15"))
3
source

Dates.daysofweekinmonth समारोह

daysofweekinmonth(dt::TimeType) -> Int

सप्ताह के dt दिन के लिए, सप्ताह के उस दिन की कुल संख्या को dt महीने में वापस करें। 4 या 5 लौटाता है। एक महीने में एक सप्ताह के अंतिम दिन को निर्दिष्ट करने के लिए टेम्पोरल एक्सप्रेशंस में उपयोगी है dayofweekofmonth(dt) == daysofweekinmonth(dt)

उदाहरण

julia> Dates.daysofweekinmonth(Date("2005-01-01"))
5

julia> Dates.daysofweekinmonth(Date("2005-01-04"))
4
source

Dates.monthname समारोह

monthname(dt::TimeType; locale="english") -> String

के महीने का पूरा नाम लौटें Date या DateTime दिए गए में locale

उदाहरण

julia> Dates.monthname(Date("2005-01-04"))
"January"
source

Dates.monthabbr समारोह

monthabbr(dt::TimeType; locale="english") -> String

का संक्षिप्त माह नाम वापस Date या DateTime दिए गए में locale

उदाहरण

julia> Dates.monthabbr(Date("2005-01-04"))
"Jan"
source

Dates.daysinmonth समारोह

daysinmonth(dt::TimeType) -> Int

महीने में कितने दिन लौटाएं dt । मान 28, 29, 30 या 31 होगा।

उदाहरण

julia> Dates.daysinmonth(Date("2000-01"))
31

julia> Dates.daysinmonth(Date("2001-02"))
28

julia> Dates.daysinmonth(Date("2000-02"))
29
source

Dates.isleapyear समारोह

isleapyear(dt::TimeType) -> Bool

true यदि dt एक लीप वर्ष है , तो वापसी करें ।

उदाहरण

julia> Dates.isleapyear(Date("2004"))
true

julia> Dates.isleapyear(Date("2005"))
false
source

Dates.dayofyear समारोह

dayofyear(dt::TimeType) -> Int

dt 1 जनवरी दिन 1 होने के साथ वर्ष का दिन लौटाएं ।

source

Dates.daysinyear समारोह

daysinyear(dt::TimeType) -> Int

366 लौटें यदि वर्ष का dt लीप वर्ष है, अन्यथा 365 वापस करें।

उदाहरण

julia> Dates.daysinyear(1999)
365

julia> Dates.daysinyear(2000)
366
source

Dates.quarterofyear समारोह

quarterofyear(dt::TimeType) -> Int

उस क्वार्टर को लौटाएं जो अंदर dt रहता है। मूल्य की सीमा 1: 4 है।

source

Dates.dayofquarter समारोह

dayofquarter(dt::TimeType) -> Int

वर्तमान तिमाही के दिन लौटें dt । मान की सीमा 1:92 है।

source

समायोजक कार्य

Base.trunc तरीका

trunc(dt::TimeType, ::Type{Period}) -> TimeType

dt उपलब्ध Period प्रकार के अनुसार मूल्य को काटता है ।

उदाहरण

julia> trunc(Dates.DateTime("1996-01-01T12:30:00"), Dates.Day)
1996-01-01T00:00:00
source

Dates.firstdayofweek समारोह

firstdayofweek(dt::TimeType) -> TimeType

dt अपने सप्ताह के सोमवार को समायोजित करता है।

उदाहरण

julia> Dates.firstdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-01T00:00:00
source

Dates.lastdayofweek समारोह

lastdayofweek(dt::TimeType) -> TimeType

dt अपने सप्ताह के रविवार को समायोजित करता है।

उदाहरण

julia> Dates.lastdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-07T00:00:00
source

Dates.firstdayofmonth समारोह

firstdayofmonth(dt::TimeType) -> TimeType

dt अपने महीने के पहले दिन को समायोजित करता है।

उदाहरण

julia> Dates.firstdayofmonth(DateTime("1996-05-20"))
1996-05-01T00:00:00
source

Dates.lastdayofmonth समारोह

lastdayofmonth(dt::TimeType) -> TimeType

dt अपने महीने के अंतिम दिन में समायोजित करता है।

उदाहरण

julia> Dates.lastdayofmonth(DateTime("1996-05-20"))
1996-05-31T00:00:00
source

Dates.firstdayofyear समारोह

firstdayofyear(dt::TimeType) -> TimeType

dt अपने वर्ष के पहले दिन को समायोजित करता है।

उदाहरण

julia> Dates.firstdayofyear(DateTime("1996-05-20"))
1996-01-01T00:00:00
source

Dates.lastdayofyear समारोह

lastdayofyear(dt::TimeType) -> TimeType

dt अपने वर्ष के अंतिम दिन को समायोजित करता है।

उदाहरण

julia> Dates.lastdayofyear(DateTime("1996-05-20"))
1996-12-31T00:00:00
source

Dates.firstdayofquarter समारोह

firstdayofquarter(dt::TimeType) -> TimeType

dt अपनी तिमाही के पहले दिन के लिए समायोजित ।

उदाहरण

julia> Dates.firstdayofquarter(DateTime("1996-05-20"))
1996-04-01T00:00:00

julia> Dates.firstdayofquarter(DateTime("1996-08-20"))
1996-07-01T00:00:00
source

Dates.lastdayofquarter समारोह

lastdayofquarter(dt::TimeType) -> TimeType

dt अपनी तिमाही के अंतिम दिन तक समायोजित ।

उदाहरण

julia> Dates.lastdayofquarter(DateTime("1996-05-20"))
1996-06-30T00:00:00

julia> Dates.lastdayofquarter(DateTime("1996-08-20"))
1996-09-30T00:00:00
source

Dates.tonext तरीका

tonext(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

समायोजित करता है dt करने के लिए इसी सप्ताह के अगले दिन के लिए dow साथ 1 = Monday, 2 = Tuesday, etc । सेटिंग same=true वर्तमान dt को अगले के रूप में माना जाता है dow , जिससे समायोजन नहीं होने की अनुमति मिलती है।

source

Dates.toprev तरीका

toprev(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

समायोजित करता है dt करने के लिए इसी सप्ताह के पिछले दिन की dow साथ 1 = Monday, 2 = Tuesday, etc । सेटिंग same=true वर्तमान dt को पिछली के रूप में माना जाता है dow , जिससे समायोजन नहीं होने की अनुमति मिलती है।

source

Dates.tofirst समारोह

tofirst(dt::TimeType, dow::Int; of=Month) -> TimeType

अपने महीने dt के पहले को समायोजित करता है dow । वैकल्पिक रूप से, वर्ष of=Year के पहले को समायोजित करेगा dow

source

Dates.tolast समारोह

tolast(dt::TimeType, dow::Int; of=Month) -> TimeType

इसके महीने dt के आखिरी dow में समायोजित करता है । वैकल्पिक रूप से, वर्ष of=Year के अंतिम dow में समायोजित किया जाएगा ।

source

Dates.tonext तरीका

tonext(func::Function, dt::TimeType; step=Day(1), limit=10000, same=false) -> TimeType

रिटर्न तक इन्क्रीमेंट द्वारा dt अधिकांश limit पुनरावृत्तियों पर पुनरावृत्ति करके समायोजित करता है । एक ही तर्क लेना चाहिए और एक लौटाना चाहिए । को संतोषजनक मानने की अनुमति देता है । step func true func TimeType Bool same dt func

source

Dates.toprev तरीका

toprev(func::Function, dt::TimeType; step=Day(-1), limit=10000, same=false) -> TimeType

रिटर्न तक इन्क्रीमेंट द्वारा dt अधिकांश limit पुनरावृत्तियों पर पुनरावृत्ति करके समायोजित करता है । एक ही तर्क लेना चाहिए और एक लौटाना चाहिए । को संतोषजनक मानने की अनुमति देता है । step func true func TimeType Bool same dt func

source

काल

Dates.Period तरीका

Year(v)
Month(v)
Week(v)
Day(v)
Hour(v)
Minute(v)
Second(v)
Millisecond(v)
Microsecond(v)
Nanosecond(v)

Period दिए गए v मान के साथ एक प्रकार का निर्माण करें । इनपुट दोषरहित रूप से परिवर्तनीय होना चाहिए a Int64

source

Dates.CompoundPeriod तरीका

CompoundPeriod(periods) -> CompoundPeriod

एक का निर्माण CompoundPeriod एक से Vector की Period है। Period एक ही प्रकार के सभी को एक साथ जोड़ा जाएगा।

उदाहरण

julia> Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13))
25 hours

julia> Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1))
-1 hour, 1 minute

julia> Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2))
1 month, -2 weeks

julia> Dates.CompoundPeriod(Dates.Minute(50000))
50000 minutes
source

Dates.default समारोह

default(p::Period) -> Period

इनपुट अवधि के T(1) लिए वर्ष, महीना और दिन और T(0) घंटे, मिनट, दूसरा, और मिलेसेकंड के लिए लौटकर एक समझदार "डिफ़ॉल्ट" मान देता है ।

source

गोल कार्य

Date और DateTime मूल्यों के लिए एक निर्दिष्ट संकल्प (जैसे, 1 महीने या 15 मिनट) के साथ करने के लिए गोल किया जा सकता है floor , ceil या round

Base.floor तरीका

floor(dt::TimeType, p::Period) -> TimeType

प्रस्ताव पर निकटतम Date या उससे DateTime कम या उसके बराबर लौटें । dt p

सुविधा के लिए, p मूल्य के बजाय एक प्रकार हो सकता है: के floor(dt, Dates.Hour) लिए एक शॉर्टकट है floor(dt, Dates.Hour(1))

julia> floor(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> floor(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:30:00

julia> floor(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-06T00:00:00
source

Base.ceil तरीका

ceil(dt::TimeType, p::Period) -> TimeType

प्रस्ताव पर पास Date या DateTime बराबर या उससे अधिक पास लौटाएं । dt p

सुविधा के लिए, p मूल्य के बजाय एक प्रकार हो सकता है: के ceil(dt, Dates.Hour) लिए एक शॉर्टकट है ceil(dt, Dates.Hour(1))

julia> ceil(Date(1985, 8, 16), Dates.Month)
1985-09-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:45:00

julia> ceil(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-07T00:00:00
source

Base.round तरीका

round(dt::TimeType, p::Period, [r::RoundingMode]) -> TimeType

Date या प्रस्ताव पर DateTime निकटतम लौटें । डिफ़ॉल्ट रूप से ( ), संबंधों (जैसे, 9:30 से निकटतम घंटे तक) को गोल किया जाएगा। dt p RoundNearestTiesUp

सुविधा के लिए, p मूल्य के बजाय एक प्रकार हो सकता है: के round(dt, Dates.Hour) लिए एक शॉर्टकट है round(dt, Dates.Hour(1))

julia> round(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> round(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:30:00

julia> round(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-07T00:00:00

मान्य राउंडिंग के लिए मोड round(::TimeType, ::Period, ::RoundingMode) कर रहे हैं RoundNearestTiesUp , (डिफ़ॉल्ट) RoundDown ( floor ), और RoundUp ( ceil )।

source

अधिकांश Period मानों को एक निर्दिष्ट रिज़ॉल्यूशन के लिए भी गोल किया जा सकता है:

Base.floor तरीका

floor(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

x के निकटतम एकाधिक के लिए नीचे राउंड precision । तो x और precision के विभिन्न उपप्रकार हैं Period , वापसी मान के रूप में एक ही प्रकार होगा precision

सुविधा के लिए, precision मूल्य के बजाय एक प्रकार हो सकता है: के floor(x, Dates.Hour) लिए एक शॉर्टकट है floor(x, Dates.Hour(1))

julia> floor(Dates.Day(16), Dates.Week)
2 weeks

julia> floor(Dates.Minute(44), Dates.Minute(15))
30 minutes

julia> floor(Dates.Hour(36), Dates.Day)
1 day

एक करने के लिए गोलाई precision का Month रों या Year रों, समर्थित नहीं है के रूप में इन Period रों असंगत लंबाई के होते हैं।

source

Base.ceil तरीका

ceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

x के निकटतम एकाधिक तक गोल करें precision । तो x और precision के विभिन्न उपप्रकार हैं Period , वापसी मान के रूप में एक ही प्रकार होगा precision

सुविधा के लिए, precision मूल्य के बजाय एक प्रकार हो सकता है: के ceil(x, Dates.Hour) लिए एक शॉर्टकट है ceil(x, Dates.Hour(1))

julia> ceil(Dates.Day(16), Dates.Week)
3 weeks

julia> ceil(Dates.Minute(44), Dates.Minute(15))
45 minutes

julia> ceil(Dates.Hour(36), Dates.Day)
2 days

एक करने के लिए गोलाई precision का Month रों या Year रों, समर्थित नहीं है के रूप में इन Period रों असंगत लंबाई के होते हैं।

source

Base.round तरीका

round(x::Period, precision::T, [r::RoundingMode]) where T <: Union{TimePeriod, Week, Day} -> T

x के निकटतम एकाधिक में गोल precision । तो x और precision के विभिन्न उपप्रकार हैं Period , वापसी मान के रूप में एक ही प्रकार होगा precision । डिफ़ॉल्ट रूप से ( RoundNearestTiesUp ), संबंधों (जैसे, 90 मिनट निकटतम घंटे तक) को गोल किया जाएगा।

सुविधा के लिए, precision मूल्य के बजाय एक प्रकार हो सकता है: के round(x, Dates.Hour) लिए एक शॉर्टकट है round(x, Dates.Hour(1))

julia> round(Dates.Day(16), Dates.Week)
2 weeks

julia> round(Dates.Minute(44), Dates.Minute(15))
45 minutes

julia> round(Dates.Hour(36), Dates.Day)
2 days

मान्य राउंडिंग के लिए मोड round(::Period, ::T, ::RoundingMode) कर रहे हैं RoundNearestTiesUp , (डिफ़ॉल्ट) RoundDown ( floor ), और RoundUp ( ceil )।

एक करने के लिए गोलाई precision का Month रों या Year रों, समर्थित नहीं है के रूप में इन Period रों असंगत लंबाई के होते हैं।

source

निम्नलिखित कार्य निर्यात नहीं किए जाते हैं:

Dates.floorceil समारोह

floorceil(dt::TimeType, p::Period) -> (TimeType, TimeType)

इसके साथ ही लौटने floor और ceil एक की Date या DateTime संकल्प पर p । दोनों को floor और ceil व्यक्तिगत रूप से कॉल करने की तुलना में अधिक कुशल ।

source
floorceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> (T, T)

इसके साथ ही लौटने floor और ceil का Period संकल्प पर p । दोनों को floor और ceil व्यक्तिगत रूप से कॉल करने की तुलना में अधिक कुशल ।

source

Dates.epochdays2date समारोह

epochdays2date(days) -> Date

राउंडिंग युग ( 0000-01-01T00:00:00 ) के बाद से दिनों की संख्या लें और संबंधित को वापस करें Date

source

Dates.epochms2datetime समारोह

epochms2datetime(milliseconds) -> DateTime

गोल युग ( 0000-01-01T00:00:00 ) के बाद से मिलीसेकंड की संख्या लें और संबंधित को वापस करें DateTime

source

Dates.date2epochdays समारोह

date2epochdays(dt::Date) -> Int64

दिए गए को लें Date और गोल युग ( 0000-01-01T00:00:00 ) के रूप में दिनों की संख्या वापस करें Int64

source

Dates.datetime2epochms समारोह

datetime2epochms(dt::DateTime) -> Int64

दिए गए को लें DateTime और गोल युग ( 0000-01-01T00:00:00 ) के बाद से मिलीसेकंड की संख्या वापस करें Int64

source

रूपांतरण कार्य

Dates.today समारोह

today() -> Date

की तारीख वाले हिस्से को वापस करें now()

source

Dates.unix2datetime समारोह

unix2datetime(x) -> DateTime

यूनिक्स युग के बाद से सेकंड की संख्या ले लो 1970-01-01T00:00:00 और इसी में परिवर्तित DateTime

source

Dates.datetime2unix समारोह

datetime2unix(dt::DateTime) -> Float64

दिए गए को लें DateTime और यूनिक्स के बाद से सेकंड की संख्या 1970-01-01T00:00:00 को एक के रूप में वापस करें Float64

source

Dates.julian2datetime समारोह

julian2datetime(julian_days) -> DateTime

युग के बाद से जूलियन कैलेंडर दिनों की संख्या ले लो -4713-11-24T12:00:00 और इसी वापसी DateTime

source

Dates.datetime2julian समारोह

datetime2julian(dt::DateTime) -> Float64

दी ले लो DateTime और जूलियन अवधि के बाद जूलियन कैलेंडर दिनों की संख्या वापसी -4713-11-24T12:00:00 एक के रूप में Float64

source

Dates.rata2datetime समारोह

rata2datetime(days) -> DateTime

युगों से राता के मरने के दिनों की संख्या लें 0000-12-31T00:00:00 और संबंधित को वापस करें DateTime

source

Dates.datetime2rata समारोह

datetime2rata(dt::TimeType) -> Int64

दिए गए Date या से युग के बाद से राता मर दिनों की संख्या लौटाएं DateTime

source

स्थिरांक

सप्तह के दिन:

परिवर्तनशील Abbr। मान (इंट)
Monday Mon 1
Tuesday Tue 2
Wednesday Wed 3
Thursday Thu 4
Friday Fri 5
Saturday Sat 6
Sunday Sun 7

साल के महीने:

परिवर्तनशील Abbr। मान (इंट)
January Jan 1
February Feb 2
March Mar 3
April Apr 4
May May 5
June Jun 6
July Jul 7
August Aug 8
September Sep 9
October Oct 10
November Nov 1 1
December Dec 12

Original text