Quel est le module / méthode utilisé pour obtenir l'heure actuelle?

2742
user46646 6 janv. 2009 à 07:54

30 réponses

Meilleure réponse

Utilisation:

>>> import datetime
>>> datetime.datetime.now()
datetime.datetime(2009, 1, 6, 15, 8, 24, 78915)

>>> print(datetime.datetime.now())
2009-01-06 15:08:24.789150

Et juste le temps:

>>> datetime.datetime.now().time()
datetime.time(15, 8, 24, 78915)

>>> print(datetime.datetime.now().time())
15:08:24.789150

Voir la documentation pour plus d'informations.

Pour enregistrer la saisie, vous pouvez importer l'objet datetime à partir du module datetime:

>>> from datetime import datetime

Supprimez ensuite le datetime. en tête de tout ce qui précède.

2911
RTHarston 29 oct. 2019 à 17:00

Par défaut, la fonction now() renvoie la sortie au format YYYY-MM-DD HH:MM:SS:MS. Utilisez l'exemple de script ci-dessous pour obtenir la date et l'heure actuelles dans un script Python et imprimer les résultats à l'écran. Créez le fichier getDateTime1.py avec le contenu ci-dessous.

import datetime

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

La sortie ressemble à ci-dessous:

2018-03-01 17:03:46.759624
14
Peter Mortensen 6 juin 2018 à 23:03

Cette question n'a pas besoin d'une nouvelle réponse juste pour le plaisir ... un jouet / module brillant et nouveau, cependant, est une justification suffisante. Cela étant la bibliothèque de pendule, qui semble faire le genre de choses que la flèche a tenté, sauf sans le défauts et bogues inhérents qui assaillent la flèche.

Par exemple, la réponse à la question d'origine:

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

Il y a beaucoup de normes qui doivent être adressées, y compris plusieurs RFC et ISO, pour s'inquiéter. Jamais les mélanger; ne vous inquiétez pas, jetez un œil à dir(pendulum.constants). Il y a cependant un peu plus que les formats RFC et ISO.

Quand nous disons local, que voulons-nous dire? Eh bien, je veux dire:

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

Vraisemblablement, la plupart d'entre vous veulent dire ailleurs.

Et ça continue. Pour faire court: Pendulum tente de faire pour la date et l'heure ce que les requêtes ont fait pour HTTP. Cela vaut la peine d'être considéré, en particulier pour sa facilité d'utilisation et sa documentation complète.

13
Ben 28 déc. 2019 à 22:47

Parce que personne ne l'a encore mentionné, et c'est quelque chose que j'ai rencontré récemment ... la méthode fromutc () d'un fuseau horaire pytz combinée avec utcnow () de datetime est le meilleur moyen que j'ai trouvé pour obtenir une heure actuelle (et une date) utiles dans n'importe quel fuseau horaire.

from datetime import datetime

import pytz


JST = pytz.timezone("Asia/Tokyo")


local_time = JST.fromutc(datetime.utcnow())

Si tout ce que vous voulez, c'est l'heure, vous pouvez l'obtenir avec local_time.time().

8
kungphu 6 juil. 2018 à 08:24

Essayez le module flèche de http://crsmithdev.com/arrow/:

import arrow
arrow.now()

Ou la version UTC:

arrow.utcnow()

Pour modifier sa sortie, ajoutez .format ():

arrow.utcnow().format('YYYY-MM-DD HH:mm:ss ZZ')

Pour un fuseau horaire spécifique:

arrow.now('US/Pacific')

Il y a une heure:

arrow.utcnow().replace(hours=-1)

Ou si vous voulez l'essentiel.

arrow.get('2013-05-11T21:23:58.970460+00:00').humanize()
>>> '2 years ago'
13
Peter Mortensen 6 juin 2018 à 22:52

Ce qui suit est ce que j'utilise pour obtenir le temps sans avoir à formater. Certaines personnes n'aiment pas la méthode de partage, mais elle est utile ici:

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

Il imprimera au format HH: MM: SS.

6
Peter Mortensen 6 juin 2018 à 22:51

Comment obtenir l'heure actuelle en Python?

Le module time

Le module time fournit des fonctions qui nous indiquent le temps en "secondes depuis l'époque" ainsi que d'autres utilitaires.

import time

Unix Epoch Time

Il s'agit du format dans lequel vous devez obtenir des horodatages pour l'enregistrement dans les bases de données. Il s'agit d'un simple nombre à virgule flottante qui peut être converti en entier. Il est également bon pour l'arithmétique en secondes, car il représente le nombre de secondes depuis le 1er janvier 1970 00:00:00, et c'est une lumière de mémoire par rapport aux autres représentations du temps que nous examinerons ensuite:

>>> time.time()
1424233311.771502

Cet horodatage ne tient pas compte des secondes intercalaires, il n'est donc pas linéaire - les secondes intercalaires sont ignorées. Donc, même s'il n'est pas équivalent à la norme internationale UTC, il est proche, et donc assez bon pour la plupart des cas de tenue de registres.

Cependant, ce n'est pas idéal pour la planification humaine. Si vous avez un événement futur que vous souhaitez avoir lieu à un certain moment, vous voudrez stocker cette heure avec une chaîne qui peut être analysée dans un objet datetime ou un objet datetime sérialisé (ceux-ci seront décrits plus loin).

time.ctime

Vous pouvez également représenter l'heure actuelle de la manière préférée par votre système d'exploitation (ce qui signifie qu'elle peut changer lorsque vous modifiez vos préférences système, alors ne vous fiez pas à cela pour être standard sur tous les systèmes, comme j'ai vu que d'autres l'attendent) . Ceci est généralement convivial, mais ne donne généralement pas lieu à un tri chronologique:

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

Vous pouvez également hydrater les horodatages sous une forme lisible par l'homme avec ctime:

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

Cette conversion n'est pas non plus bonne pour la tenue de dossiers (sauf dans le texte qui ne sera analysé que par les humains - et avec une reconnaissance optique des caractères et une intelligence artificielle améliorées, je pense que le nombre de ces cas diminuera).

Module datetime

Le module datetime est également très utile ici:

>>> import datetime

datetime.datetime.now

Le datetime.now est une méthode de classe qui renvoie l'heure actuelle. Il utilise le time.localtime sans les informations de fuseau horaire (s'il n'est pas donné, sinon consultez le fuseau horaire ci-dessous). Il a une représentation (qui vous permettrait de recréer un objet équivalent) en écho sur le shell, mais lorsqu'il est imprimé (ou contraint à un str), il est au format lisible par l'homme (et presque ISO), et le lexicographique le tri est équivalent au tri chronologique:

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

utcnow de datetime

Vous pouvez obtenir un objet datetime en temps UTC, une norme globale, en procédant comme suit:

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

L'UTC est une norme de temps presque équivalente au fuseau horaire GMT. (Bien que GMT et UTC ne changent pas pour l'heure d'été, leurs utilisateurs peuvent passer à d'autres fuseaux horaires, comme l'heure d'été britannique, pendant l'été.)

Prise en compte du fuseau horaire datetime

Cependant, aucun des objets datetime que nous avons créés jusqu'à présent ne peut être facilement converti en différents fuseaux horaires. Nous pouvons résoudre ce problème avec le module pytz:

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

De manière équivalente, en Python 3, nous avons la classe timezone avec une instance utc timezone attachée, ce qui rend également le fuseau horaire de l'objet conscient (mais pour convertir en un autre fuseau horaire sans que le module pytz maniable soit laissé comme exercice au lecteur):

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

Et nous voyons que nous pouvons facilement convertir en fuseaux horaires à partir de l'objet utc d'origine.

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

Vous pouvez également rendre un objet datetime naïf conscient avec la méthode pytz timezone localize, ou en remplaçant l'attribut tzinfo (avec replace, cela se fait à l'aveugle), mais ce sont plus de derniers recours que les meilleures pratiques:

>>> 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>)

Le module pytz nous permet de faire prendre conscience à nos datetime objets du fuseau horaire et de convertir les heures en centaines de fuseaux horaires disponibles dans le module pytz.

On pourrait ostensiblement sérialiser cet objet pour l'heure UTC et stocker cela dans une base de données, mais cela nécessiterait beaucoup plus de mémoire et serait plus sujet aux erreurs que de simplement stocker l'heure Unix Epoch, ce que j'ai démontré en premier.

Les autres façons de visualiser les heures sont beaucoup plus sujettes aux erreurs, en particulier lorsqu'il s'agit de données qui peuvent provenir de différents fuseaux horaires. Vous voulez qu'il n'y ait aucune confusion quant au fuseau horaire auquel une chaîne ou un objet datetime sérialisé était destiné.

Si vous affichez l'heure avec Python pour l'utilisateur, ctime fonctionne bien, pas dans un tableau (il ne trie généralement pas bien), mais peut-être dans une horloge. Cependant, je recommande personnellement, lorsque vous traitez avec le temps en Python, d'utiliser du temps Unix ou un objet UTC datetime compatible avec le fuseau horaire.

341
Aaron Hall 10 juin 2016 à 20:42
import datetime
date_time = str(datetime.datetime.now()).split()
date,time = date_time

date imprimera la date et heure imprimera l'heure.

6
Abhijeet Deshani 24 janv. 2019 à 19:58

Vous pouvez utiliser time.strftime() :

>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'
919
Honest Abe 20 févr. 2013 à 21:17

.isoformat() est dans la documentation, mais pas encore ici (c'est très similaire à la réponse de @Ray Vega):

>>> import datetime
>>> datetime.datetime.now().isoformat()
'2013-06-24T20:35:55.982000'
36
Peter Mortensen 6 juin 2018 à 22:44

Vous pouvez utiliser le module time:

import time
print time.strftime("%d/%m/%Y")

>>> 06/02/2015

L'utilisation du capital Y donne l'année complète et l'utilisation de y donnerait 06/02/15.

Vous pouvez également utiliser le code suivant pour donner un temps plus long:

time.strftime("%a, %d %b %Y %H:%M:%S")
>>> 'Fri, 06 Feb 2015 17:45:09'
22
Georgy 31 mai 2019 à 09:09

Faire

from time import time

t = time()
  • t - nombre flottant, bon pour la mesure d'intervalle de temps.

Il existe une certaine différence pour les plates-formes Unix et Windows.

130
Kevin Guan 4 déc. 2015 à 06:46

Cette question s'adresse à Python mais comme Django est l'un des frameworks les plus utilisés pour Python, il est important de noter que si vous utilisez Django, vous pouvez toujours utiliser timezone.now() au lieu de datetime.datetime.now(). Le premier est «conscient» du fuseau horaire tandis que le second ne l'est pas.

Voir cette réponse SO et la Django doc pour les détails et la justification de timezone.now().

from django.utils import timezone

now = timezone.now()
6
Georgy 5 juin 2019 à 11:50

Les réponses précédentes sont toutes de bonnes suggestions, mais je trouve qu'il est plus facile d'utiliser ctime():

In [2]: from time import ctime
In [3]: ctime()
Out[3]: 'Thu Oct 31 11:40:53 2013'

Cela donne une représentation sous forme de chaîne bien formatée de l'heure locale actuelle.

69
Peter Mortensen 19 sept. 2019 à 14:09
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

Faites dir(date) ou toutes les variables, y compris le package. Vous pouvez obtenir tous les attributs et méthodes associés à la variable.

18
Peter Mortensen 6 juin 2018 à 22:55

Similaire à réponse de Harley, mais utilisez la {{ Fonction X0}} pour un format lisible rapidement et légèrement plus humain:

>>> from datetime import datetime
>>> str(datetime.now())
'2011-05-03 17:45:35.177000'
447
Community 23 mai 2017 à 11:47

Je veux avoir le temps avec des millisecondes. Un moyen simple de les obtenir:

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

Mais je veux seulement quelques millisecondes , non? Le moyen le plus court de les obtenir:

import time

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

Ajoutez ou supprimez des zéros de la dernière multiplication pour ajuster le nombre de décimales, ou simplement:

def get_time_str(decimal_points=3):
    return time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 10**decimal_points)
12
Peter Mortensen 6 juin 2018 à 22:54

Pourquoi ne pas demander aux États-Unis Naval Observatory, le chronométreur officiel de la marine américaine?

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

Si vous vivez dans la zone D.C. (comme moi) la latence n'est peut-être pas trop mauvaise ...

32
C8H10N4O2 19 août 2016 à 19:45

datetime.now() renvoie l'heure actuelle sous la forme d'un objet datetime naïf qui représente l'heure dans le fuseau horaire local. Cette valeur peut être ambiguë, par exemple, pendant les transitions DST ("repli"). Pour éviter toute ambiguïté, l'un des fuseaux horaires UTC doit être utilisé:

from datetime import datetime

utc_time = datetime.utcnow()
print(utc_time) # -> 2014-12-22 22:48:59.916417

Ou un objet sensible au fuseau horaire auquel les informations de fuseau horaire correspondantes sont attachées (Python 3.2+):

from datetime import datetime, timezone

now = datetime.now(timezone.utc).astimezone()
print(now) # -> 2014-12-23 01:49:25.837541+03:00
18
jfs 22 déc. 2014 à 22:52

Heure actuelle d'un fuseau horaire

from datetime import datetime
import pytz

tz_NY = pytz.timezone('America/New_York') 
datetime_NY = datetime.now(tz_NY)
print("NY time:", datetime_NY.strftime("%H:%M:%S"))

tz_London = pytz.timezone('Europe/London')
datetime_London = datetime.now(tz_London)
print("London time:", datetime_London.strftime("%H:%M:%S"))

tz_India = pytz.timezone('Asia/India')
datetime_India = datetime.now(tz_India)
print("India time:", datetime_India.strftime("%H:%M:%S"))
7
Georgy 18 oct. 2019 à 13:51

Vous pouvez utiliser cette fonction pour obtenir l'heure (malheureusement, elle ne dit pas AM ou PM):

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

Pour obtenir les heures, minutes, secondes et millisecondes à fusionner plus tard, vous pouvez utiliser ces fonctions:

Heure:

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

Minute:

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

Deuxième:

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

Milliseconde:

def getmillisecond():
    from datetime import datetime
    return (str(datetime.now())).split('.')[1]
9
scrpy 13 août 2019 à 16:51

Si vous utilisez déjà numpy, vous pouvez directement utiliser la fonction numpy.datetime64 ().

import numpy as np
str(np.datetime64('now'))

Pour seule date:

str(np.datetime64('today'))

Ou, si vous utilisez déjà des pandas, vous pouvez utiliser la fonction pandas.to_datetime ()

import pandas as pd
str(pd.to_datetime('now'))

Ou,

str(pd.to_datetime('today'))
24
durjoy 31 mai 2019 à 11:59

C'est ce que j'ai fini par faire:

>>>from time import strftime
>>>strftime("%m/%d/%Y %H:%M")
01/09/2015 13:11

En outre, ce tableau est une référence nécessaire pour choisir les codes de format appropriés pour obtenir la date formatée comme vous le souhaitez (à partir de la documentation Python "datetime" ici).

strftime format code table

27
Kristen G. 9 janv. 2015 à 18:24

Utiliser les pandas pour obtenir l'heure actuelle, sorte de surpuissance du problème actuel:

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)

Production:

2017-09-22 12:44:56.092642
2017-09-22
2017
9
22
12
44
56
92693
30
Georgy 31 mai 2019 à 09:06
from datetime import datetime
datetime.now().strftime('%Y-%m-%d %H:%M:%S')

Pour cet exemple, la sortie sera comme ceci: '2013-09-18 11:16:32'

Voici la liste des strftime directives.

576
Bob Stein 23 janv. 2020 à 13:46
>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %X +0000", gmtime())
'Tue, 06 Jan 2009 04:54:56 +0000'

Cela génère le GMT actuel dans le format spécifié. Il existe également une méthode localtime().

Cette page contient plus de détails.

98
Georgy 31 mai 2019 à 08:53

Si vous voulez juste l'horodatage actuel en ms (par exemple, pour mesurer le temps d'exécution), vous pouvez également utiliser le module "timeit":

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))
10
motagirl2 18 juil. 2018 à 07:11
>>> import datetime, time
>>> time = time.strftime("%H:%M:%S:%MS", time.localtime())
>>> print time
'00:21:38:20S'
16
pokkie 14 sept. 2019 à 12:10

Le moyen le plus rapide est:

>>> import time
>>> time.strftime("%Y%m%d")
'20130924'
54
Peter Mortensen 19 sept. 2019 à 14:03

Si vous avez besoin de l'heure actuelle en tant qu'objet time:

>>> import datetime
>>> now = datetime.datetime.now()
>>> datetime.time(now.hour, now.minute, now.second)
datetime.time(11, 23, 44)
47
Rob I 23 nov. 2011 à 18:08