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

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' datetimeobjet à partir du datetimemodule:

>>> from datetime import datetime

Retirez ensuite l'interligne datetime.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, la sortie sera comme ceci: '2013-09-18 11:16:32'

Voici la liste des strftimedirectives .

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?

Le timemodule

Le timemodule 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. 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 module

Le datetimemodule est également très utile ici:

>>> import datetime

datetime.datetime.now

La datetime.nowest une méthode de classe qui renvoie l'heure actuelle. Il utilise le time.localtimesans 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

datetime's 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é.)

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

>>> 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 timezoneclasse avec une timezoneinstance utc attachée, ce qui rend également le fuseau horaire de l'objet conscient (mais la conversion en un autre fuseau horaire sans le pytzmodule 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 pytztimezone 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 pytzmodule nous permet de rendre nos datetimefuseaux horaires conscients et de convertir les heures en centaines de fuseaux horaires disponibles dans le pytzmodule.

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 ctimefonctionne 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 datetimeobjet 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'

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

>>> import datetime
>>> now = datetime.datetime.now()
>>> datetime.time(now.hour, now.minute, now.second)
datetime.time(11, 23, 44)

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

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

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

>>> 06/02/2015

L’utilisation du capital Ydonne l’année complète et l’utilisation ydonnerait06/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, 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:MSformat. 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.pyavec 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'

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.