मैं पाइथन में वर्तमान समय कैसे प्राप्त करूं?

time मॉड्यूल

time मॉड्यूल उन कार्यों को प्रदान करता है जो हमें "युग के बाद से सेकंड" के साथ-साथ अन्य उपयोगिताओं में भी समय बताते हैं।

import time

यूनिक्स युग टाइम

यह प्रारूप है जिसे आपको डेटाबेस में सहेजने के लिए टाइमस्टैम्प मिलना चाहिए। यह एक साधारण फ़्लोटिंग पॉइंट नंबर है जिसे एक पूर्णांक में परिवर्तित किया जा सकता है। यह सेकंड में अंकगणित के लिए भी अच्छा है, क्योंकि यह 1 जनवरी 1 9 70 00:00:00 के बाद से सेकंड की संख्या का प्रतिनिधित्व करता है, और यह समय के अन्य प्रस्तुतियों के सापेक्ष मेमोरी लाइट है जिसे हम अगले पर देखेंगे:

>>> time.time()
1424233311.771502

यह टाइमस्टैम्प लीप-सेकंड के लिए खाता नहीं है, इसलिए यह रैखिक नहीं है - लीप सेकंड अनदेखा कर रहे हैं। इसलिए जब यह अंतरराष्ट्रीय यूटीसी मानक के बराबर नहीं है, तो यह करीब है, और इसलिए रिकॉर्ड रखने के अधिकांश मामलों के लिए काफी अच्छा है।

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

time.ctime

आप अपने ऑपरेटिंग सिस्टम द्वारा पसंदीदा तरीके से वर्तमान समय का भी प्रतिनिधित्व कर सकते हैं (जिसका अर्थ यह है कि जब आप अपनी सिस्टम वरीयताओं को बदलते हैं तो यह बदल सकता है, इसलिए इस पर भरोसा न करें कि सभी प्रणालियों में मानक हो, जैसा कि मैंने दूसरों को उम्मीद की है) । यह आम तौर पर उपयोगकर्ता के अनुकूल है, लेकिन आम तौर पर स्ट्रिंग्स में परिणामस्वरूप कोई क्रमिक रूप से क्रमबद्ध नहीं हो सकता है:

>>> time.ctime()
'Tue Feb 17 23:21:56 2015'

आप ctime को मानव पठनीय रूप में ctime साथ हाइड्रेट भी कर सकते हैं:

>>> time.ctime(1424233311.771502)
'Tue Feb 17 23:21:51 2015'

यह रूपांतरण रिकॉर्ड-रखरखाव के लिए भी अच्छा नहीं है (पाठ को छोड़कर जिसे केवल मनुष्यों द्वारा पार्स किया जाएगा - और बेहतर ऑप्टिकल कैरेक्टर रिकग्निशन और आर्टिफिशियल इंटेलिजेंस के साथ, मुझे लगता है कि इन मामलों की संख्या कम हो जाएगी)।

datetime मॉड्यूल

datetime मॉड्यूल भी काफी उपयोगी है:

>>> import datetime

datetime.datetime.now

datetime.now एक क्लास विधि है जो वर्तमान समय लौटाती है। यह time.localtime जानकारी के बिना समय का उपयोग करता है। अगर नहीं दिया जाता है, अन्यथा नीचे दिए गए time.localtime को देखें)। इसमें एक प्रतिनिधित्व (जो आपको समकक्ष वस्तु को फिर से बनाने की अनुमति देगा) खोल पर प्रतिबिंबित होता है, लेकिन जब मुद्रित (या एक str लिए मजबूर), यह मानव पठनीय (और लगभग आईएसओ) प्रारूप में है, और लेक्सिकोग्राफिक प्रकार के बराबर है कालक्रम क्रमबद्ध करें:

>>> datetime.datetime.now()
datetime.datetime(2015, 2, 17, 23, 43, 49, 94252)
>>> print(datetime.datetime.now())
2015-02-17 23:43:51.782461

utcnow के बारे में utcnow

आप यूटीसी समय, एक वैश्विक मानक में एक डाटाटाइम ऑब्जेक्ट प्राप्त कर सकते हैं, ऐसा करके:

>>> datetime.datetime.utcnow()
datetime.datetime(2015, 2, 18, 4, 53, 28, 394163)
>>> print(datetime.datetime.utcnow())
2015-02-18 04:53:31.783988

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

डेटाटाइम टाइमज़ोन जागरूक

हालांकि, अब तक बनाए गए डेटाटाइम ऑब्जेक्ट्स में से कोई भी आसानी से विभिन्न टाइमज़ोन में परिवर्तित नहीं किया जा सकता है। हम उस समस्या को pytz मॉड्यूल के साथ हल कर सकते हैं:

>>> import pytz
>>> then = datetime.datetime.now(pytz.utc)
>>> then
datetime.datetime(2015, 2, 18, 4, 55, 58, 753949, tzinfo=<UTC>)

समान रूप से, पायथन 3 में हमारे पास टाइमकोन क्लास है जिसमें एक यूटीसी टाइमज़ोन इंस्टेंस संलग्न है, जो ऑब्जेक्ट टाइमज़ोन को भी जागरूक करता है (लेकिन आसान pytz मॉड्यूल के बिना किसी अन्य pytz कनवर्ट करने के लिए पाठक को व्यायाम के रूप में छोड़ दिया जाता है):

>>> datetime.datetime.now(datetime.timezone.utc)
datetime.datetime(2015, 2, 18, 22, 31, 56, 564191, tzinfo=datetime.timezone.utc)

और हम देखते हैं कि हम आसानी से मूल utc ऑब्जेक्ट से टाइमज़ोन में परिवर्तित कर सकते हैं।

>>> print(then)
2015-02-18 04:55:58.753949+00:00
>>> print(then.astimezone(pytz.timezone('US/Eastern')))
2015-02-17 23:55:58.753949-05:00

आप एक pytz ऑब्जेक्ट को pytz localize विधि से अवगत pytz , या tzinfo विशेषता को replace करके ( replace , यह अंधा कर दिया गया है), लेकिन ये सर्वोत्तम प्रथाओं की तुलना में अधिक अंतिम रिसॉर्ट्स हैं:

>>> pytz.utc.localize(datetime.datetime.utcnow())
datetime.datetime(2015, 2, 18, 6, 6, 29, 32285, tzinfo=<UTC>)
>>> datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
datetime.datetime(2015, 2, 18, 6, 9, 30, 728550, tzinfo=<UTC>)

pytz मॉड्यूल हमें हमारे pytz को जागरूक करने और pytz मॉड्यूल में उपलब्ध सैकड़ों pytz में कनवर्ट करने की अनुमति देता है।

कोई भी यूटीसी समय के लिए इस ऑब्जेक्ट को स्पष्ट रूप से क्रमबद्ध कर सकता है और डेटाबेस में स्टोर कर सकता है, लेकिन इसे यूनिक्स एपोक टाइम को संग्रहीत करने की तुलना में कहीं अधिक स्मृति की आवश्यकता होगी और त्रुटि के अधिक प्रवण होने की आवश्यकता होगी, जिसे मैंने पहले प्रदर्शित किया था।

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

यदि आप उपयोगकर्ता के लिए पाइथन के साथ समय प्रदर्शित कर रहे हैं, तो ctime अच्छी तरह से काम करता है, तालिका में नहीं (यह आमतौर पर अच्छी तरह से क्रमबद्ध नहीं होता है), लेकिन शायद एक घड़ी में। हालांकि, मैं व्यक्तिगत रूप से सलाह देता हूं कि पाइथन में समय के साथ काम करते समय, या तो यूनिक्स समय का उपयोग करें, या एक टाइमज़ोन जागरूक यूटीसी datetime ऑब्जेक्ट का उपयोग करें।

आप time.strftime() उपयोग कर सकते हैं:

>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'

आप समय प्राप्त करने के लिए इस फ़ंक्शन का उपयोग कर सकते हैं (दुर्भाग्यवश यह एएम या पीएम नहीं कहता है):

def gettime():
        from datetime import datetime
        return ((str(datetime.now())).split(' ')[1]).split('.')[0]

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

घंटे:

def gethour():
        from datetime import datetime
        return return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[0]

मिनट:

def getminute():
        from datetime import datetime
        return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[1]

दूसरा:

def getsecond():
        from datetime import datetime
        return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[2]

मिलीसेकंड:

def getmillisecond():
        from datetime import datetime
        return return (str(datetime.now())).split('.')[1]

इस सवाल के लिए सिर्फ एक नए उत्तर की आवश्यकता नहीं है ... हालांकि, चमकदार नया-आश खिलौना / मॉड्यूल पर्याप्त औचित्य है। वह पेंडुलम लाइब्रेरी है , जो तीर से गुजरने वाली निहित त्रुटियों और बगों को छोड़कर, तीर का प्रयास करने वाली चीजों को करने के लिए प्रतीत होता है।

उदाहरण के लिए, मूल प्रश्न का उत्तर:

>>> import pendulum
>>> print(pendulum.now())
2018-08-14T05:29:28.315802+10:00
>>> print(pendulum.utcnow())
2018-08-13T19:29:35.051023+00:00

इसके बारे में चिंता करने के लिए कई मानक हैं जिन्हें कई आरएफसी और आईएसओ सहित संबोधित करने की आवश्यकता है। कभी उन्हें मिलाएं; चिंता न करें, dir(pendulum.constants) में थोड़ा नज़र डालें, हालांकि आरएफसी और आईएसओ प्रारूपों की तुलना में थोड़ा अधिक है।

जब हम स्थानीय कहते हैं, तो हमारा क्या मतलब है? खैर मेरा मतलब है:

>>> print(pendulum.now().timezone_name)
Australia/Melbourne
>>>

संभवतः आप में से अधिकांश का मतलब कहीं और है।

और यह जाता है। लंबी कहानी छोटी: पेंडुलम तिथि और समय के लिए करने का प्रयास करता है जो HTTP के लिए अनुरोध करता था। यह विशेष रूप से उपयोग और व्यापक दस्तावेज़ीकरण दोनों के लिए विचार करने योग्य है।

करना

from time import time

t = time()

• t - फ्लोट नंबर, समय अंतराल माप के लिए अच्छा है।

यूनिक्स और विंडोज प्लेटफॉर्म के लिए कुछ अंतर है।

डिफ़ॉल्ट रूप से, now() फ़ंक्शन YYYY-MM-DD HH:MM:SS:MS में आउटपुट देता है YYYY-MM-DD HH:MM:SS:MS प्रारूप। पाइथन लिपि में वर्तमान दिनांक और समय प्राप्त करने के लिए नीचे दिए गए नमूना स्क्रिप्ट का उपयोग करें और स्क्रीन पर प्रिंट परिणाम। नीचे दी गई सामग्री के साथ फ़ाइल getDateTime1.py बनाएं।

import datetime

currentDT = datetime.datetime.now()
print (str(currentDT))

आउटपुट नीचे जैसा दिखता है:

2018-03-01 17:03:46.759624

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

from time import ctime
print ctime().split()[3]

यह एचएच में प्रिंट होगा: एमएम: एसएस प्रारूप।

मैं मिलीसेकंड के साथ समय प्राप्त करना चाहता हूं। उन्हें पाने का एक आसान तरीका:

import time, datetime

print(datetime.datetime.now().time())                         # 11:20:08.272239

# Or in a more complicated way
print(datetime.datetime.now().time().isoformat())             # 11:20:08.272239
print(datetime.datetime.now().time().strftime('%H:%M:%S.%f')) # 11:20:08.272239

# But do not use this:
print(time.strftime("%H:%M:%S.%f", time.localtime()), str)    # 11:20:08.%f

लेकिन मुझे केवल मिलीसेकंड चाहिए , है ना? उन्हें पाने का सबसे छोटा तरीका:

import time

time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 1000)
# 11:34:23.751

दशमलव बिंदुओं की संख्या समायोजित करने के लिए अंतिम गुणा से शून्य को जोड़ें या हटाएं, या बस:

def get_time_str(decimal_points=3):
    return time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 10**decimal_points)

यदि आप बस एमएस में वर्तमान टाइमस्टैंप चाहते हैं (उदाहरण के लिए, निष्पादन समय को मापने के लिए), तो आप "टाइमिट" मॉड्यूल का भी उपयोग कर सकते हैं:

import timeit
start_time = timeit.default_timer()
do_stuff_you_want_to_measure()
end_time = timeit.default_timer()
print("Elapsed time: {}".format(end_time - start_time))

यदि आपको time वस्तु के रूप में वर्तमान समय की आवश्यकता है:

>>> import datetime
>>> now = datetime.datetime.now()
>>> datetime.time(now.hour, now.minute, now.second)
datetime.time(11, 23, 44)

वर्तमान समय प्राप्त करने के लिए Pandas का उपयोग करना, समस्या को खत्म करने की तरह:

import pandas as pd
print (pd.datetime.now())
print (pd.datetime.now().date())
print (pd.datetime.now().year)
print (pd.datetime.now().month)
print (pd.datetime.now().day)
print (pd.datetime.now().hour)
print (pd.datetime.now().minute)
print (pd.datetime.now().second)
print (pd.datetime.now().microsecond)

आउटपुट:

2017-09-22 12:44:56.092642
2017-09-22
2017
9
22
12
44
56
92693

सबसे तेज़ तरीका है

>>> import time
>>> time.strftime("%Y%m%d")
'20130924'

सरल और आसान:

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

import datetime
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

आउटपुट:

2017-10-17 23:48:55

या

time का उपयोग करना,

import time
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))

आउटपुट:

2017-10-17 18:22:26

हार्ले के उत्तर की तरह , लेकिन एक त्वरित-एन-गंदे के लिए str() फ़ंक्शन का उपयोग करें, थोड़ा अधिक मानव पठनीय प्रारूप:

>>> from datetime import datetime
>>> str(datetime.now())
'2011-05-03 17:45:35.177000'

अमेरिकी नौसेना वेधशाला , संयुक्त राज्य अमेरिका नौसेना के आधिकारिक टाइमकीपर से क्यों न पूछें?

import requests
from lxml import html

page = requests.get('http://tycho.usno.navy.mil/cgi-bin/timer.pl')
tree = html.fromstring(page.content)
print(tree.xpath('//html//body//h3//pre/text()')[1])

यदि आप डीसी क्षेत्र में रहते हैं (मेरे जैसे) विलंबता बहुत खराब नहीं हो सकती है ...

.isoformat() प्रलेखन में है, लेकिन अभी तक नहीं है (यह @ रे वेगा के उत्तर के समान शक्तिशाली है):

>>> import datetime
>>> datetime.datetime.now().isoformat()
'2013-06-24T20:35:55.982000'

>>> from datetime import datetime
>>> datetime.now().strftime('%Y-%m-%d %H:%M:%S')

इस उदाहरण के लिए, आउटपुट इस तरह होगा: '2013-09-18 11:16:32'

strftime की सूची यहां दी गई है।

>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %X +0000", gmtime())
'Tue, 06 Jan 2009 04:54:56 +0000'

यह निर्दिष्ट प्रारूप में वर्तमान जीएमटी आउटपुट करता है। एक लोकलटाइम () विधि भी है।

इस page में अधिक जानकारी है।

from time import ctime

// Day {Mon,Tue,..}
print ctime().split()[0]
// Month {Jan, Feb,..}
print ctime().split()[1]
// Date {1,2,..}
print ctime().split()[2]
// HH:MM:SS
print ctime().split()[3]
// Year {2018,..}
print ctime().split()[4]

जब आप ctime () को कॉल करते हैं तो यह 'दिन महीना दिनांक एचएच: एमएम: एसएस ईयर' (उदाहरण के लिए: 17 जनवरी 16:53:22 2018 ') प्रारूप में स्ट्रिंग में सेकेंड को परिवर्तित करेगा, फिर आप विभाजन () विधि को कॉल करते हैं आपकी स्ट्रिंग ['बुध', 'जनवरी', '17', '16:56:45', '2018'] से एक सूची बनायेगा (डिफ़ॉल्ट डिलीमीटर अंतरिक्ष है)।

सूची में वांछित तर्क 'चयन' करने के लिए ब्रैकेट का उपयोग किया जाता है।

किसी को केवल एक कोड लाइन कॉल करनी चाहिए। किसी को उन्हें ऐसा नहीं करना चाहिए जैसा मैंने किया था, यह सिर्फ एक उदाहरण था, क्योंकि कुछ मामलों में आपको अलग-अलग मूल्य मिलेंगे, दुर्लभ लेकिन असंभव मामले नहीं होंगे।

import datetime
date_time = datetime.datetime.now()

date = date_time.date()  # Gives the date
time = date_time.time()  # Gives the time

print date.year, date.month, date.day
print time.hour, time.minute, time.second, time.microsecond

पैकेज सहित dir(date) या किसी भी चर। आप चर के साथ जुड़े सभी विशेषताओं और विधियों को प्राप्त कर सकते हैं।