मिलीसेकंड के साथ एक स्ट्रिंग में एक डेटाइम फॉर्मेट करें

Question

मैं datetimeमिलिसेकंड के साथ तारीख से एक स्ट्रिंग करना चाहता हूं । यह कोड मेरे लिए विशिष्ट है और मैं इसे छोटा करने के लिए सीखने के लिए उत्सुक हूं।

from datetime import datetime

timeformatted= str(datetime.utcnow())
semiformatted= timeformatted.replace("-","")
almostformatted= semiformatted.replace(":","")
formatted=almostformatted.replace(".","")
withspacegoaway=formatted.replace(" ","")
formattedstripped=withspacegoaway.strip()
print formattedstripped

Comments

stackoverflow.com/questions/311627/…

— cetver

कृपया एक शीर्षक लिखें जो आपकी समस्या का वर्णन करता है और आपके प्रश्न को स्पष्ट और बिंदु पर रखने की कोशिश करता है।

— एएफएफ

यह यहाँ ध्यान देने योग्य है कि अतिरिक्त परिशुद्धता अक्सर ठीक होती है। उदाहरण के लिए, जावा के Instant.parseसाथ बनाए गए strftime('%Y-%m-%dT%H:%M:%S.%fZ')

— पुनर्मुद्रण

Answer 1

मिलीसेकंड के साथ दिनांक स्ट्रिंग प्राप्त करने के लिए (सेकंड के पीछे 3 दशमलव स्थान), इसका उपयोग करें:

from datetime import datetime

print datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]

>>>> OUTPUT >>>>
2020-05-04 10:18:32.926

नोट: पायथन 3 के लिए, printकोष्ठक की आवश्यकता है:

print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])

Comments

सटीक होना, 2013-08-23 10:18:32.926का आउटपुट है print datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3] ।

— जान

ध्यान दें, यदि आप import datetimeइसके बजाय उपयोग करना चाहते हैं, तो आपको इसका उपयोग करना from datetime import datetimeहोगा:datetime.datetime.utcnow().strftime("%H:%M:%S.%f")

— ल्यूक

मामले में माइक्रोसेकंड 0 हैं, विंडोज़ में 2.7 कार्यान्वयन माइक्रोसेकंड प्रिंट नहीं होते हैं, इसलिए यह सेकंड में ट्रिम कर देता है :(

— कैबी

ध्यान दें कि यह छोटा हो जाता है, मिलीसेकंड तक गोल नहीं होता है

— gens

जैसा कि उल्लेख है, यह गलत नहीं होगा यह पहली बूंदों की संख्या है> = 5 ?. वास्तव में अगर usec हिस्सा> 999500 है, तो आपको माइक्रोसेकंड भाग के साथ फ़िडलिंग करके कभी भी सही समय नहीं मिलेगा

— क्रिस

Answer 2

अजगर 3.6 के साथ आप उपयोग कर सकते हैं:

from datetime import datetime
datetime.utcnow().isoformat(sep=' ', timespec='milliseconds')

आउटपुट:

'2019-05-10 09:08:53.155'

अधिक जानकारी यहाँ: https://docs.python.org/3/library/datetime.html#datetime.datetime.ofofatat

Comments

समय-क्षेत्र के साथ भी उपयोगी: दिनांक = डेटाटाइम (2019,5,10) दिनांक_with_tz = pytz.timezone ('यूरोप / रोम')। स्थानीयकरण (दिनांक) दिनांक_with_tz.isoformat (sep = 'T', timespec = 'milliseconds') आउटपुट: आउटपुट। '2019-05-10T00: 00: 00.000 + 02: 00'

— Ena

यह वास्तविक समाधान है जिसे स्वीकार किया जाना चाहिए। और isoformat () क्या मुझे GPX प्रारूप में निर्यात की आवश्यकता है, बहुत बहुत धन्यवाद!

— फ़िलिप हैप्पी

Answer 3

print datetime.utcnow().strftime('%Y%m%d%H%M%S%f')

http://docs.python.org/library/datetime.html#strftime-strptime-behavior

Comments

FYI करें, यह पिछले 6 अंकों के रूप में माइक्रोसेकंड प्रिंट करता है। [:-3]अंतिम 3 अंकों को छोड़ने के लिए अंत में जोड़ें ताकि यह केवल मिलीसेकंड प्रदर्शित हो।

— मार्क लकाटा

माइक्रोसेकंड 6 अंकों से कम हो सकता है, इसलिए [: -3] गलत मिलीसेकंड प्रिंट कर रहा है

— टैक्सी 26

क्या होगा अगर हमारे पास समय है?

— at देवमम्बरिस

@ Zone टाइमजोन चेकआउट लोरेंजो के उत्तर के लिए देवम्बरीस

— Ena

Answer 4

@ कैबी ने यह मुद्दा उठाया कि कुछ प्रणालियों पर, माइक्रोसेकंड प्रारूप %fदे सकता है"0" , इसलिए पिछले तीन वर्णों को काट देना पोर्टेबल नहीं है।

निम्नलिखित कोड सावधानी से मिलीसेकंड के साथ टाइमस्टैम्प प्रारूपित करता है:

from datetime import datetime
(dt, micro) = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f').split('.')
dt = "%s.%03d" % (dt, int(micro) / 1000)
print dt

उदाहरण आउटपुट:

2016-02-26 04:37:53.133

ओपी चाहता था कि सटीक उत्पादन प्राप्त करने के लिए, हमें विराम चिह्नों को हटाना होगा:

from datetime import datetime
(dt, micro) = datetime.utcnow().strftime('%Y%m%d%H%M%S.%f').split('.')
dt = "%s%03d" % (dt, int(micro) / 1000)
print dt

उदाहरण आउटपुट:

20160226043839901

Comments

मैं वास्तव में क्या कर रहा हूँ यह है: प्रिंट '% s।% 03d'% (dt.strftime ("% Y-% m-% d% H:% M:% S"), int (dt.microsecond / 1000 ))

— कैबबी

@ cabbi से सहमत, स्ट्रिंग और इंट के साथ आगे और पीछे कन्वर्ट करने की कोई आवश्यकता नहीं है

— काओनन

हाँ, मैं भी सहमत हूँ ... :)

— सैम वाटकिंस

यह उत्तर अन्य की तुलना में बहुत अधिक सटीक और सुरक्षित है। धन्यवाद !

— हुनफू

Answer 5

शायद इस तरह:

import datetime
now = datetime.datetime.now()
now.strftime('%Y/%m/%d %H:%M:%S.%f')[:-3]  
# [:-3] => Removing the 3 last characters as %f is for microsecs.

Comments

दूसरा %mएक होना चाहिए %M, क्योंकि यह मिनट है, महीनों नहीं।

— माइकल डॉर्नर

Answer 6

मुझे लगता है कि आप मतलब है कि आप कुछ है कि datetime.datetime.strftime () की तुलना में तेजी से देख रहे हैं, और अनिवार्य रूप से एक utc टाइमस्टैम्प से गैर-अल्फा वर्णों को अलग कर रहे हैं।

आप दृष्टिकोण थोड़ा तेज कर रहे हैं, और मुझे लगता है कि आप स्ट्रिंग को टुकड़ा करके और भी अधिक गति कर सकते हैं:

>>> import timeit
>>> t=timeit.Timer('datetime.utcnow().strftime("%Y%m%d%H%M%S%f")','''
... from datetime import datetime''')
>>> t.timeit(number=10000000)
116.15451288223267

>>> def replaceutc(s):
...     return s\
...         .replace('-','') \
...         .replace(':','') \
...         .replace('.','') \
...         .replace(' ','') \
...         .strip()
... 
>>> t=timeit.Timer('replaceutc(str(datetime.datetime.utcnow()))','''
... from __main__ import replaceutc
... import datetime''')
>>> t.timeit(number=10000000)
77.96774983406067

>>> def sliceutc(s):
...     return s[:4] + s[5:7] + s[8:10] + s[11:13] + s[14:16] + s[17:19] + s[20:]
... 
>>> t=timeit.Timer('sliceutc(str(datetime.utcnow()))','''
... from __main__ import sliceutc
... from datetime import datetime''')
>>> t.timeit(number=10000000)
62.378515005111694

Comments

@oxtopus अच्छा काम। व्यक्तिगत रूप से, मैं का उपयोग नहीं करते timeit अब और समय की सरल मापने के लिए। यह अजीब है कि समय के अनुपात आपके कोड के साथ अलग-अलग हैं: 1 - 0.67 - 0.53 और मेरे साथ: 1 - 0.35 - 0.20, तरीकों के लिए strftime - बदलें - स्लाइसिंग

— eyquem

हो सकता है कि परीक्षण के प्रत्येक पुनरावृत्ति बनाम एक बार सेट किए जा रहे str (datetime.datetime.utcnow ()) के साथ कुछ करना है?

— ऑस्टिन मार्शल

Answer 7

from datetime import datetime
from time import clock

t = datetime.utcnow()
print 't == %s    %s\n\n' % (t,type(t))

n = 100000

te = clock()
for i in xrange(1):
    t_stripped = t.strftime('%Y%m%d%H%M%S%f')
print clock()-te
print t_stripped," t.strftime('%Y%m%d%H%M%S%f')"

print

te = clock()
for i in xrange(1):
    t_stripped = str(t).replace('-','').replace(':','').replace('.','').replace(' ','')
print clock()-te
print t_stripped," str(t).replace('-','').replace(':','').replace('.','').replace(' ','')"

print

te = clock()
for i in xrange(n):
    t_stripped = str(t).translate(None,' -:.')
print clock()-te
print t_stripped," str(t).translate(None,' -:.')"

print

te = clock()
for i in xrange(n):
    s = str(t)
    t_stripped = s[:4] + s[5:7] + s[8:10] + s[11:13] + s[14:16] + s[17:19] + s[20:] 
print clock()-te
print t_stripped," s[:4] + s[5:7] + s[8:10] + s[11:13] + s[14:16] + s[17:19] + s[20:] "

परिणाम

t == 2011-09-28 21:31:45.562000    <type 'datetime.datetime'>


3.33410112179
20110928212155046000  t.strftime('%Y%m%d%H%M%S%f')

1.17067364707
20110928212130453000 str(t).replace('-','').replace(':','').replace('.','').replace(' ','')

0.658806915404
20110928212130453000 str(t).translate(None,' -:.')

0.645189262881
20110928212130453000 s[:4] + s[5:7] + s[8:10] + s[11:13] + s[14:16] + s[17:19] + s[20:]

अनुवाद का उपयोग () और स्लाइसिंग विधि एक ही समय में
अनुवाद () लाभ प्रस्तुत करता है एक पंक्ति में प्रयोग करने योग्य होने के लिए

पहले एक के आधार पर समय की तुलना:

1.000 * t.strftime ('% Y% m% d% H% M% S% f')

0.351 * str (t) .replace ('-', '')। प्रतिस्थापित करें (':', '') '। प्रतिस्थापित करें (' '' ',' ')।' '(' ',' ') को प्रतिस्थापित करें।

0.198 * str (t) .translate (कोई नहीं, '-': ')।

0.194 * s [: 4] + s [5: 7] + s [8:10] + s [11:13] + s [14:16] + s [17:19] + s [20:]

Comments

अच्छा! यह वास्तव में प्रदर्शन का त्याग किए बिना क्लीनर है। str.translate () वास्तव में मेरे परीक्षण में तेज है।

— ऑस्टिन मार्शल

Answer 8

मैं एक ही समस्या से निपटता था लेकिन मेरे मामले में यह महत्वपूर्ण था कि मिलीसेकंड को गोल किया गया था और इसे काट नहीं दिया गया था

from datetime import datetime, timedelta

def strftime_ms(datetime_obj):
    y,m,d,H,M,S = datetime_obj.timetuple()[:6]
    ms = timedelta(microseconds = round(datetime_obj.microsecond/1000.0)*1000)
    ms_date = datetime(y,m,d,H,M,S) + ms
    return ms_date.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]

Answer 9

import datetime

# convert string into date time format.

str_date = '2016-10-06 15:14:54.322989'
d_date = datetime.datetime.strptime(str_date , '%Y-%m-%d %H:%M:%S.%f')
print(d_date)
print(type(d_date)) # check d_date type.


# convert date time to regular format.

reg_format_date = d_date.strftime("%d %B %Y %I:%M:%S %p")
print(reg_format_date)

# some other date formats.
reg_format_date = d_date.strftime("%Y-%m-%d %I:%M:%S %p")
print(reg_format_date)
reg_format_date = d_date.strftime("%Y-%m-%d %H:%M:%S")
print(reg_format_date)

<<<<<<< OUTPUT >>>>>>>

2016-10-06 15:14:54.322989    
<class 'datetime.datetime'>    
06 October 2016 03:14:54 PM    
2016-10-06 03:14:54 PM    
2016-10-06 15:14:54

Answer 10

python -c "from datetime import datetime; print str(datetime.now())[:-3]"
2017-02-09 10:06:37.006

Answer 11

datetime
t = datetime.datetime.now()
ms = '%s.%i' % (t.strftime('%H:%M:%S'), t.microsecond/1000)
print(ms)
14:44:37.134

Answer 12

के साथ समस्या datetime.utcnow() तरह के और अन्य समाधानों के है कि वे धीमे हैं।

अधिक कुशल समाधान इस तरह दिख सकता है:

def _timestamp(prec=0):
    t = time.time()
    s = time.strftime("%H:%M:%S", time.localtime(t))
    if prec > 0:
        s += ("%.9f" % (t % 1,))[1:2+prec]
    return s

आपके मामले में (मिलीसेकंड) कहां precहोगा 3।

फ़ंक्शन 9 दशमलव स्थानों तक काम करता है (कृपया 92 स्वरूपण स्ट्रिंग में संख्या पर ध्यान दें )।

यदि आप भिन्नात्मक भाग को गोल करना चाहते हैं, तो मैं सुझाव देता हूं कि "%.9f"वांछित स्थानों के साथ गतिशील रूप से निर्माण करना चाहिए ।