Ik wil een datetimeString van de datum met milliseconden. Deze code is typisch voor mij en ik ben enthousiast om te leren hoe ik het moet verkorten.
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
Antwoord 1, Autoriteit 100%
Om een datumstring te krijgen met milliseconden (3 decimalen achter seconden), gebruikt u dit:
from datetime import datetime
print datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
>>>> OUTPUT >>>>
2020-05-04 10:18:32.926
Opmerking: voor Python3, printvereist haakjes:
print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
Antwoord 2, Autoriteit 22%
Met Python 3.6 U kunt gebruiken:
from datetime import datetime
datetime.utcnow().isoformat(sep=' ', timespec='milliseconds')
Uitgang:
'2019-05-10 09:08:53.155'
Meer info hier: https: //docs.python. org / 3 / bibliotheek / datetime.html # datetime.datetime.isoformat
Antwoord 3, Autoriteit 6%
print datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
http://docs.python.org/library/datetime. html#strftime-strptime-behaviour
Antwoord 4, autoriteit 5%
@Cabbi bracht het probleem ter sprake dat op sommige systemen het microsecondenformaat %f"0"kan geven, dus het is niet draagbaar om simpelweg de laatste drie tekens af te hakken .
De volgende code maakt zorgvuldig een tijdstempel op met milliseconden:
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
Voorbeelduitvoer:
2016-02-26 04:37:53.133
Om de exacte uitvoer te krijgen die de OP wilde, moeten we leestekens verwijderen:
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
Voorbeelduitvoer:
20160226043839901
Antwoord 5, autoriteit 2%
Waarschijnlijk zo:
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.
Antwoord 6
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)
& lt; & lt; & lt; & lt; & lt; & lt; Output & GT; & GT; & GT; & GT; & GT; & GT; & GT;
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
Antwoord 7
Ik neem aan dat u bedoelt dat u op zoek bent naar iets dat sneller is dan datetime.datetime.strftime (), en het in wezen de niet-alfa-tekens uit een UTC-tijdstempel uitschakelen.
Je benadering is marginaal sneller, en ik denk dat je dingen nog meer kunt versnellen door de string te snijden:
>>> 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
Antwoord 8
python -c "from datetime import datetime; print str(datetime.now())[:-3]"
2017-02-09 10:06:37.006
Antwoord 9
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:] "
resultaat
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:]
Gebruik van Vertaal () en Snijden Werkwijze in dezelfde tijd
Vertalen () presenteert het voordeel om bruikbaar te zijn in één regel
Vergelijking van de tijden op basis van de eerste:
1.000 * T.STRFTIME (‘% Y% M% D% H% m% s% f’)
0.351 * STR (T). REPLAATS (‘-‘, ”). Vervangen (‘:’, ”). Vervangen (‘.’, ”). Vervangen (‘
‘,’ ‘)0.198 * STR (T) .RANSLATE (Geen, ‘- :.’)
0.194 * S [: 4] + S [5: 7] + S [8:10] + S [11:13] + S [14:16] + S [17:19] +
s [20:]
Antwoord 10
Ik heb hetzelfde probleem behandeld, maar in mijn geval was het belangrijk dat de milliseconde afgerond en niet afgekapt
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]
Antwoord 11
datetime
t = datetime.datetime.now()
ms = '%s.%i' % (t.strftime('%H:%M:%S'), t.microsecond/1000)
print(ms)
14:44:37.134
Antwoord 12
in Python 3.6 en hoger met behulp van python f-strings :
from datetime import datetime
i = datetime.utcnow()
print(f"""{i:%Y-%m-%d %H:%M:%S}.{"{:03d}".format(i.microsecond // 1000)}""")
De code die specifiek is voor het formatteren Milliseconden is:
{"{:03d}".format(i.microsecond // 1000)}
De opmakende string {:03d}en microseconde tot milliseconde conversie // 1000is van def _format_timein https://github.com/python/cpython/blob/master/lib/datetime.py dat wordt gebruikt voor datetime.datetime.isoformat () .
Antwoord 13
Het probleem met datetime.utcnow()EN ANDERE DELATE SOLUTATIONS is dat ze traag zijn.
Efficiënte oplossing kan er zo uitzien:
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
Waar preczou zijn 3in uw geval (milliseconden).
De functie werkt maximaal 9 decimalen (gelet op nummer 9in de 2e formattering-string).
Als u het fractionele gedeelte wilt afronden, raadde ik u aan het bouwen van "%.9f"dynamisch met gewenst aantal decimalen.
Antwoord 14
Als u bereid bent om de tijd in een variabele op te slaan en een kleine stringmanipulatie uit te voeren, kunt u dit daadwerkelijk doen zonder de Datetime-module te gebruiken.
>>> _now = time.time()
>>> print ("Time : %s.%s\n" % (time.strftime('%x %X',time.localtime(_now)),
... str('%.3f'%_now).split('.')[1])) # Rounds to nearest millisecond
Time : 05/02/21 01:16:58.676
>>>
%.3f rondt af naar de dichtstbijzijnde milliseconde, als u meer of minder precisie wilt, wijzigt u gewoon het aantal decimalen
>>> print ("Time : %s.%s\n" % (time.strftime('%x %X',time.localtime(_now)),
... str('%.1f'%_now).split('.')[1])) # Rounds to nearest tenth of a second
Time : 05/02/21 01:16:58.7
>>>
Getest in Python 2.7 en 3.7 (je moet uiteraard de haakjes weglaten als je print aanroept in versie 2.x).