Quel est le module / méthode utilisé pour obtenir l'heure actuelle?
Quel est le module / méthode utilisé pour obtenir l'heure actuelle?
Réponses:
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
Consultez la documentation pour plus d'informations.
Pour enregistrer la saisie, vous pouvez importer l' datetime
objet à partir du datetime
module:
>>> from datetime import datetime
Retirez ensuite l'interligne datetime.
de tout ce qui précède.
datetime.datetime.now()
dans ma console interactive Python 2.7 (IronPython n'a pas encore été mis à jour) me donne le même comportement que l'exemple le plus récent utilisé print()
dans la réponse. Je n'ai pas répliqué avec succès ce que la réponse d'origine montre (datetime.datetime (2009, 1, 6, 15, 8, 24, 78915)). (Pas que je le veuille vraiment, le comportement print () est préféré, mais je suis curieux.)
datetime.now()
seul, il l'imprime de la même manière que le montre votre réponse print(datetime.now())
...
Vous pouvez utiliser time.strftime()
:
>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'
time
module contre le datetime
module?
localtime()
au lieu de gmtime()
pour obtenir votre heure locale.
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 .
Semblable à la réponse de Harley , mais utilisez la str()
fonction 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'
Comment obtenir l'heure actuelle en Python?
time
moduleLe time
module fournit des fonctions qui nous indiquent le temps en "secondes depuis l'époque" ainsi que d'autres utilitaires.
import 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. Ainsi, bien qu'il ne soit pas équivalent à la norme UTC internationale, il est proche, et donc assez bon pour la plupart des cas de tenue de registres.
Ce n'est cependant 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 je l'ai vu d'autres s'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 hydrater les horodatages sous une forme lisible par l'homme avec ctime
également:
>>> 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).
datetime
moduleLe datetime
module est également très utile ici:
>>> import datetime
datetime.datetime.now
La 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 voir le fuseau horaire au-dessous). Il a une représentation (qui vous permettrait de recréer un objet équivalent) en écho sur la coque, mais lorsqu'il est imprimé (ou contraint à a str
), il est au format lisible par l'homme (et presque ISO), et le tri lexicographique est équivalent à la 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
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 horaire 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é.)
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 pytz
module:
>>> 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 timezone
classe avec une timezone
instance utc attachée, ce qui rend également le fuseau horaire de l'objet conscient (mais la conversion en un autre fuseau horaire sans le pytz
module pratique est laissée en 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 des 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 pytz
module nous permet de rendre nos datetime
fuseaux horaires conscients et de convertir les heures en centaines de fuseaux horaires disponibles dans le pytz
module.
On pourrait ostensiblement sérialiser cet objet pour le temps UTC et stocker que dans une base de données, mais il faudrait beaucoup plus de mémoire et être plus sujettes à l' erreur que de stocker simplement Unix temps Epoch, que je démontrais d' abord.
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, cela 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, lors de l'utilisation de l'heure en Python, d'utiliser l'heure Unix ou un datetime
objet UTC compatible avec le fuseau horaire .
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.
>>> 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 localtime()
méthode.
Cette page contient plus de détails.
Les réponses précédentes sont toutes de bonnes suggestions, mais je trouve qu'il est plus facile à 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.
Le moyen le plus rapide est:
>>> import time
>>> time.strftime("%Y%m%d")
'20130924'
Pourquoi ne pas demander à l' US 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 DC (comme moi) la latence n'est peut-être pas trop mauvaise ...
Utiliser des pandas pour obtenir l'heure actuelle, sorte de surpasser le 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
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 exactement comme vous le souhaitez (à partir de la documentation Python "datetime" ici ).
strftime(time_format)
renvoie l'heure locale actuelle sous la forme d'une chaîne qui correspond à la donnée time_format
. Remarque: time.strftime()
et prend en datetime.strftime()
charge différents ensembles de directives, par exemple, %z
n'est pas pris en charge par time.strftime()
Python 2 .
time
fonctions de module sont des enveloppes minces autour des fonctions C correspondantes. datetime
est un niveau supérieur et il est généralement plus portable.
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'))
Vous pouvez utiliser le time
module:
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 y
donnerait06/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'
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
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 n'importe quelles variables comprenant le paquet. Vous pouvez obtenir tous les attributs et méthodes associés à la variable.
import datetime
c'est le cas datetime.datetime.now()
\ n si from datetime import datetime
c'est le casdatetime.now()
>>> import datetime, time
>>> time = time.strftime("%H:%M:%S:%MS", time.localtime())
>>> print time
'00:21:38:20S'
Par défaut, la now()
fonction renvoie la sortie au YYYY-MM-DD HH:MM:SS:MS
format. 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 un 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
Cette question n'a pas besoin d'une nouvelle réponse juste pour le plaisir ... un jouet / module brillant et neuf, cependant, est une justification suffisante. Cela étant la bibliothèque Pendulum , qui semble faire le genre de choses que la flèche a tenté, sauf sans les défauts et les 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 coup d'œil sur 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.
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"))
#list timezones
pytz.all_timezones
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'
arrow.now('Time/Zone')
peut échouer pour certains fuseaux horaires ( arrow
utilisations dateutil
qui ont cassé utc -> conversions locales qui sont utilisées à l'intérieur arrow.now()
. Remarque: pytz
n'a pas un tel problème . En outre, il existe d'autres problèmes liés au fuseau horaire
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 des 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)
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]
Seconde:
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]
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))
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 le temps, vous pouvez l'obtenir avec local_time.time()
.
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 sera imprimé au format HH: MM: SS.
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 à la timezone.now()
place dedatetime.datetime.now()
. Le premier est «conscient» du fuseau horaire tandis que le second ne l'est pas.
Voir cette réponse SO et le doc Django pour les détails et la justification derrière timezone.now()
.
from django.utils import timezone
now = timezone.now()
Vous pouvez le faire en utilisant ctime ():
from time import time, ctime
t = time()
ctime(t)
production:
Sat Sep 14 21:27:08 2019
Ces sorties sont différentes car l'horodatage renvoyé par ctime()
dépend de votre situation géographique.