Comment obtenir l'heure actuelle dans Python
Quel est le module/la méthode utilisée pour obtenir l'heure actuelle?
Utilisation:
>>> import datetime
>>> datetime.datetime.now()
datetime.datetime(2009, 1, 6, 15, 8, 24, 78915)
>>> print(datetime.datetime.now())
2018-07-29 09:17:13.812189
Et juste le temps:
>>> datetime.datetime.now().time()
datetime.time(15, 8, 24, 78915)
>>> print(datetime.datetime.now().time())
09:17:51.914526
Voir la documentation pour plus d'informations.
Pour sauvegarder la saisie, vous pouvez importer l'objet datetime à partir du module datetime:
>>> from datetime import datetime
Ensuite, supprimez le datetime. initial de tout ce qui précède.
Vous pouvez utiliser time.strftime() :
>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'
from datetime import datetime
datetime.now().strftime('%Y-%m-%d %H:%M:%S')
Pour cet exemple, le résultat sera le suivant: '2013-09-18 11:16:32'
Voici la liste des directives strftime .
Semblable à réponse de Harley , mais utilisez la fonction str() pour un format lisible très rapidement, légèrement plus humain:
>>> from datetime import datetime
>>> str(datetime.now())
'2011-05-03 17:45:35.177000'
Comment puis-je 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
Époque Unix
C'est le format dans lequel vous devez entrer des horodatages pour l'enregistrement dans les bases de données. C'est un simple nombre à virgule flottante qui peut être converti en un 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 il est léger en mémoire par rapport aux autres représentations du temps que nous examinerons ensuite:
>>> time.time()
1424233311.771502
Cet horodatage ne prend pas en compte les secondes intercalaires, il n'est donc pas linéaire - les secondes intercalaires sont ignorées. Ainsi, bien qu’elle ne soit pas équivalente à la norme internationale UTC, elle est proche, et donc très bonne pour la plupart des cas de tenue de registres.
Ce n'est pas idéal pour la planification humaine, cependant. Si vous souhaitez qu'un événement futur se produise à un moment donné, vous voudrez stocker cette heure avec une chaîne pouvant être analysée dans un objet datetime ou un objet datetime sérialisé (ceux-ci seront décrits ultérieurement).
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. Ne vous fiez donc pas à ce que ce soit la norme dans tous les systèmes, comme les autres s'attendent à le voir). . Ceci est généralement convivial, mais n'entraîne généralement pas de chaînes pouvant être triées chronologiquement:
>>> 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 bonne non plus pour la conservation des enregistrements (sauf dans un texte qui ne sera analysé que par des humains - et avec l'amélioration de la reconnaissance optique des caractères et de l'intelligence artificielle, 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
datetime.now est une méthode de classe qui renvoie l'heure actuelle. Il utilise le time.localtime sans les informations sur le fuseau horaire (s'il n'est pas renseigné, sinon, voir le fuseau horaire indiqué ci-dessous). Il a une représentation (qui vous permettrait de recréer un objet équivalent) en écho sur le Shell, mais une fois imprimé (ou contraint sur un str), il est au format lisible par l'homme (et presque ISO), et le format lexicographique. sort est équivalent à la sorte 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 date/heure en heure 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
UTC est une norme de temps presque équivalente au fuseau horaire GMT. (Tandis que GMT et UTC ne changent pas pour l'heure d'été, leurs utilisateurs peuvent passer à d'autres fuseaux horaires, tels que 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 fuseaux horaires différents. 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, dans Python 3, nous avons la classe timezone avec une instance utc timezone attachée, ce qui permet également à l'objet de connaître le fuseau horaire (mais de le convertir en un autre fuseau horaire sans le manipulateur pytz module est laissé au lecteur comme un exercice):
>>> 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 l’objet utc original.
>>> 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 mettre en évidence un objet datetime naïf avec la méthode pytz, timezone localize, ou en remplaçant l'attribut tzinfo (avec replace, cela se fait à l'aveuglette), mais il ne s'agit 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 module pytz nous permet de rendre nos fuseaux horaires datetime conscients 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 demanderait 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 modes d'affichage des heures sont beaucoup plus sujets aux erreurs, en particulier lorsqu'il s'agit de traiter des données provenant 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 date/heure sérialisé était destiné.
Si vous affichez l'heure avec Python pour l'utilisateur, ctime fonctionne bien, pas dans un tableau (le tri n'est généralement pas bien fait), mais peut-être dans une horloge. Cependant, je recommande personnellement, lorsque vous utilisez l'heure Python, d'utiliser l'heure Unix ou un objet UTC datetime sensible au fuseau horaire.
Faire
from time import time
t = time()
t- nombre flottant, bon pour la mesure d'intervalle de temps.
Il existe une différence entre les plateformes 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 affiche l'heure GMT actuelle au format spécifié. Il existe également une méthode localtime() .
Cette page a plus de détails.
Toutes les bonnes suggestions, mais je trouve plus facile d’utiliser ctime() moi-même:
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 joliment formatée de l'heure locale.
Simple et facile:
En utilisant le module datetime,
import datetime
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
Sortie:
2017-10-17 23:48:55
OU
Utiliser time,
import time
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
Sortie:
2017-10-17 18:22:26
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)
Moyen le plus rapide est
>>> import time
>>> time.strftime("%Y%m%d")
'20130924'
.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'
Pourquoi ne pas demander au S Naval Observatory , le chronomètre 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 habitez dans la région de DC (comme moi), le temps de latence n'est peut-être pas si mauvais….
Utiliser pandas pour obtenir l’heure actuelle, en quelque sorte surcharger le problème:
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)
Sortie:
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 aller avec:
>>>from time import strftime
>>>strftime("%m/%d/%Y %H:%M")
01/09/2015 13:11
De plus, ce tableau est une référence nécessaire pour choisir les codes de format appropriés afin de mettre la date au format souhaité, à partir de la documentation Python "datetime" ici ).
si vous utilisez déjà numpy, vous pouvez directement utiliser la fonction numpy.datetime64 ().
import numpy as np
str(np.datetime64('now'))
pour la date seulement:
str(np.datetime64('today'))
ou, si vous utilisez déjà pandas, alors vous pouvez utiliser la fonction pandas.to_datetime ()
import pandas as pd
str(pd.to_datetime('now'))
ou,
str(pd.to_datetime('today'))
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 quelle variable, y compris le paquet. Vous pouvez obtenir tous les attributs et méthodes associés à la variable.
Vous pouvez utiliser le module time:
import time
print time.strftime("%d/%m/%Y")
>>> 06/02/2015
L'utilisation de la majuscule 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'
datetime.now() renvoie l'heure actuelle en tant qu'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 ("replier"). Pour éviter toute ambiguïté, utilisez le fuseau horaire UTC:
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 sont associées les informations de fuseau horaire correspondantes (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
Par défaut, la fonction now() renvoie le résultat 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 pour 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 à celle ci-dessous:
2018-03-01 17:03:46.759624
Cette question n'a pas besoin d'une nouvelle réponse pour le plaisir de le faire ... un jouet/module neuf et brillant, cependant, est une justification suffisante. Cela étant le bibliothèque du pendule , qui semble faire le genre de choses que la flèche a tentées, sauf sans les défauts et bogues inhérents à la flèche.
Par exemple, la réponse à la question initiale:
>>> import pendulum
>>> print(pendulum.now())
2018-08-14T05:29:28.315802+10:00
>>> print(pendulum.utcnow())
2018-08-13T19:29:35.051023+00:00
Il faut se préoccuper de nombreuses normes, y compris de nombreux RFC et ISO. Jamais les mélanger; ne vous inquiétez pas, jetez un coup d'œil sur dir(pendulum.constants) Il existe cependant un peu plus que les formats RFC et ISO.
Quand on dit local, que veut-on dire? Bien je veux dire:
>>> print(pendulum.now().timezone_name)
Australia/Melbourne
>>>
On peut supposer que la plupart d'entre vous pensent ailleurs.
Et ça continue. Longue histoire: 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 pris en considération, en particulier pour sa facilité d’utilisation et sa documentation exhaustive.
Essayez le module flèche de http://crsmithdev.com/arrow/ :
import arrow
arrow.now()
Ou la version UTC:
arrow.utcnow()
Pour changer 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 le Gist.
arrow.get('2013-05-11T21:23:58.970460+00:00').humanize()
>>> '2 years ago'
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 millisecondes, non? Le moyen le plus court pour 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 points décimaux, ou simplement:
def get_time_str(decimal_points=3):
return time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 10**decimal_points)
>>> import datetime, time
>>> time = strftime("%H:%M:%S:%MS", time.localtime())
>>> print time
'00:20:58:20S'
Si vous voulez seulement 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 timezone de pytz, combinée à la méthode utcnow () de datetime, est le meilleur moyen que j’ai trouvé d’obtenir une heure actuelle utile (et une date). 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().
Vous pouvez utiliser cette fonction pour obtenir l'heure (malheureusement, il n'est pas dit AM ou PM):
def gettime():
from datetime import datetime
return ((str(datetime.now())).split(' ')[1]).split('.')[0]
Pour obtenir la fusion ultérieure des heures, des minutes, des secondes et des millisecondes, vous pouvez utiliser les fonctions suivantes:
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]
Ce qui suit est ce que j’utilise pour obtenir le temps sans avoir à formater. Certaines personnes n'aiment pas la méthode split, mais c'est utile ici:
from time import ctime
print ctime().split()[3]
Il sera imprimé au format HH: MM: SS.
import datetime
date_time = str(datetime.datetime.now()).split()
date,time = date_time
date imprimera la date et heure imprimera l'heure.
Cette question s'adresse à Python mais _ étant donné que 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 utilisez timezone.now() au lieu de datetime.datetime.now(). Le premier est "conscient" du fuseau horaire alors que le second ne l’est pas.
Voir this SO answer et le document Django pour plus de détails et une justification derrière timezone.now().
from Django.utils import timezone
now = timezone.now()
Obtenir les attributs date/heure actuels:
import datetime
currentDT = datetime.datetime.now()
print ("Current Year is: %d" % currentDT.year)
print ("Current Month is: %d" % currentDT.month)
print ("Current Day is: %d" % currentDT.day)
print ("Current Hour is: %d" % currentDT.hour)
print ("Current Minute is: %d" % currentDT.minute)
print ("Current Second is: %d" % currentDT.second)
print ("Current Microsecond is: %d" % currentDT.microsecond)
#!/usr/bin/python
import time;
ticks = time.time()
print "Number of ticks since "12:00am, Jan 1, 1970":", ticks
from time import ctime
// Day {Mon,Tue,..}
print ctime().split()[0]
// Month {Jan, Feb,..}
print ctime().split()[1]
// Date {1,2,..}
print ctime().split()[2]
// HH:MM:SS
print ctime().split()[3]
// Year {2018,..}
print ctime().split()[4]
Lorsque vous appelez ctime(), il convertit les secondes en chaîne au format 'Day Month Date HH:MM:SS Year' (par exemple: 'Wed January 17 16:53:22 2018'), puis vous appelez la méthode split() qui crée une liste à partir de votre chaîne ['Wed','Jan','17','16:56:45','2018'] (le délimiteur par défaut est l'espace).
Les crochets sont utilisés pour "sélectionner" l'argument recherché dans la liste.
On devrait appeler une seule ligne de code. On ne devrait pas les appeler comme je le faisais, c’était juste un exemple, parce que dans certains cas, vous obtiendrez des valeurs différentes, des cas rares mais pas impossibles.
C'est si simple. Essayer:
import datetime
date_time = str(datetime.datetime.now())
date = date_time.split()[0]
time = date_time.split()[1]
Commencez par importer le module datetime à partir de datetime
from datetime import datetime
Ensuite, affichez l'heure actuelle sous la forme 'aaaa-mm-jj hh: mm: ss'
print(str(datetime.now())
Pour obtenir uniquement le temps sous la forme 'hh: mm: ss' où ss représente le nombre total de secondes plus la fraction de secondes écoulée, il suffit de faire;
print(str(datetime.now()[11:])
La conversion de datetime.now () en chaîne génère une réponse dont le format ressemble à celui des DATES AND TIMES habituelles.