Format datetime dans une chaîne de caractères avec millisecondes

Je veux avoir un datetime chaîne à partir de la date avec millisecondes. Ce code est typique pour moi et je suis impatient d'apprendre à le raccourcir.

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
  • stackoverflow.com/questions/311627/...
  • S'il vous plaît écrire un titre qui décrit votre problème et essayez de garder votre question claire et précise.
  • Il est important de mentionner ici qu'une précision supplémentaire est souvent très bien. Par exemple, Java Instant.parse peut analyser represenation créé avec strftime('%Y-%m-%dT%H:%M:%S.%fZ')
InformationsquelleAutor Jurudocs | 2011-09-28
  1. 266

    Pour obtenir une chaîne de date avec la milliseconde (3 décimales derrière secondes), utilisez ceci:

    from datetime import datetime

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

>>>> OUTPUT >>>>
2018-10-04 10:18:32.926
    • La seule réponse correcte. À moins que le demandeur signifie microsecondes
    • Pour être précis, 2013-08-23 10:18:32.926 est la sortie de print datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3] .
    • bonne prise. Je fixe ma réponse en conséquence
    • Remarque, si vous souhaitez utiliser import datetime au lieu de from datetime import datetime, vous aurez à utiliser ceci: datetime.datetime.utcnow().strftime("%H:%M:%S.%f")
    • Dans le cas où une microseconde 0, windows 2.7 mise en œuvre microsecondes ne sont pas imprimés, afin qu'il garnitures secondes 🙁
    • vous pouvez l'utiliser à la place: (dt, micro) = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f').split('.') ; dt = "%s.%03d" % (dt, int(micro) / 1000) ; print dt. J'ai ajouté cela comme une réponse.
    • notez que cela tronque, pas de tours de millisecondes
    • (dt, micro) = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f').split('.') ; dt = "%s.%03d" % (dt, round(int(micro) / 1000.0)) ; print dt
    • Que les gens mentionne, n'est ce pas cela l'obtenez incorrecte, les premières gouttes nombre >=5?. En fait, si l'usec partie est > 999500, alors vous n'obtiendrez jamais le bon moment en jouant avec microsecondes partie
    • python la vie de hacks

    InformationsquelleAutor Jeremy Moritz
  2. 18
    print datetime.utcnow().strftime('%Y%m%d%H%M%S%f')

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

    • Pour info, cela s'imprime microsecondes que les 6 derniers chiffres. Ajouter [:-3] à la fin de déposer les 3 derniers chiffres de telle sorte que c'est seulement l'affichage de millisecondes.
    • microsecondes peut être de moins de 6 chiffres, [: -3] est l'impression de mal millisecondes
    • que faire si nous avons fuseau horaire?
    • le fuseau horaire pour la caisse de Lorenzo répondre
    InformationsquelleAutor knitti
  3. 10

    @Cabbi soulevé la question que sur certains systèmes, le nombre de microsecondes format %f peut donner "0", il n'est donc pas portable tout simplement de couper les trois derniers caractères.

    Le code suivant attentivement les formats de type timestamp avec millisecondes:

    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

    Exemple De Sortie:

    2016-02-26 04:37:53.133

    Pour obtenir la sortie exacte que l'OP voulait, nous avons à la bande de caractères de ponctuation:

    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

    Exemple De Sortie:

    20160226043839901
    • Ce que je suis en train de faire est ceci: print " %s.%03d'%(dt.strftime("%Y-%m-%d %H:%M:%S"), int(dt.microseconde/1000))
    • d'accord avec @cabbi, il n'y a pas besoin de convertir en arrière avec string et int
    • ouais je suis d'accord aussi... 🙂
    • Cette réponse est beaucoup plus précise et plus sûre que les autres. Merci !
    InformationsquelleAutor Sam Watkins
  4. 7

    Avec Python 3.6 vous pouvez utiliser:

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

    De sortie:

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

    Plus d'infos ici: https://docs.python.org/3/library/datetime.html#datetime.datetime.isoformat

    • Utile avec le fuseau horaire trop: date = datetime(2019,5,10) date_with_tz = pytz.le fuseau horaire ("Europe/Rome").localiser le(date) date_with_tz.isoformat(sep='T', timespec='millisecondes') de sortie: '2019-05-10T00:00:00.000+02:00'
    InformationsquelleAutor Lorenzo
  5. 2

    Je suppose que vous dire que vous êtes à la recherche de quelque chose qui est plus rapide que le type datetime.datetime.strftime(), et sont essentiellement le décapage de la non-caractères alpha à partir d'un horodatage utc.

    Vous êtes l'approche est légèrement plus rapide, et je pense que vous pouvez accélérer encore plus les choses par tranchage de la chaîne:

    >>> 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
    • Du bon travail. Personnellement, je n'utilise pas timeit plus simple de mesure de temps. Il est étrange que les ratios de délais sont différents avec votre code: 1 - 0.67 - 0.53 et avec le mien: 1 - 0.35 - 0.20 pour les méthodes de strftime - remplacer - découpage
    • Peut-être quelque chose à voir avec le str(datetime.datetime.utcnow()) étant appelée à chaque itération de l'épreuve de vs réglage une fois?
    InformationsquelleAutor Austin Marshall
  6. 2

    Sans doute comme cela :

    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.
    • La deuxième %m doit être un %M, car il est à quelques minutes, et non des mois.
    InformationsquelleAutor N Fayçal
  7. 1
    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:] "

    résultat

    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:]

    Utilisation de translate() et découpage méthode s'exécuter en même temps

    translate() présente l'avantage d'être utilisable en une seule ligne

    Comparant la fois sur la base de la première:

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

    0.351 * str(t).replace('-',").replace(':',").replace('.',").replace('
    ',")

    0.198 * str(t).traduire(None,' -:.')

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

    • Nice! C'est en effet nettoyant sans sacrifier les performances. str.translate() effectivement plus rapide lors de mes tests.
    InformationsquelleAutor eyquem
  8. 1

    J'ai traité avec le même problème, mais dans mon cas, il était important que l'ordre de la milliseconde est arrondi et non tronquée

    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]
    InformationsquelleAutor omdaniel
  9. 1
    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)

    <<<<<< PRODUIT >>>>>>>

    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
    InformationsquelleAutor Waqas Ali
  10. 1
    python -c "from datetime import datetime; print str(datetime.now())[:-3]"
2017-02-09 10:06:37.006
    InformationsquelleAutor arntg
  11. 0
    datetime
t = datetime.datetime.now()
ms = '%s.%i' % (t.strftime('%H:%M:%S'), t.microsecond/1000)
print(ms)
14:44:37.134
    InformationsquelleAutor Hunaphu