¿Cuál es el módulo / método utilizado para obtener la hora actual?

Utilizar:

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

Y justo el tiempo:

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

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

Consulte la documentación para más información.

Para guardar la escritura, puede importar el datetimeobjeto desde el datetimemódulo:

>>> from datetime import datetime

Luego, quite la guía datetime.de todo lo anterior.

Puedes usar 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')

Para este ejemplo, la salida será así: '2013-09-18 11:16:32'

Aquí está la lista de strftimedirectivas .

Similar a la respuesta de Harley , pero usa la str()función para un formato rápido y sucio, un poco más legible para los humanos:

>>> from datetime import datetime
>>> str(datetime.now())
'2011-05-03 17:45:35.177000'

¿Cómo obtengo la hora actual en Python?

El timemódulo

El timemódulo proporciona funciones que nos dicen el tiempo en "segundos desde la época", así como otras utilidades.

import time

Unix Epoch Time

Este es el formato en el que debe obtener marcas de tiempo para guardar en bases de datos. Es un número de coma flotante simple que se puede convertir en un entero. También es bueno para la aritmética en segundos, ya que representa el número de segundos desde el 1 de enero de 1970 a las 00:00:00, y es luz de memoria en relación con las otras representaciones de tiempo que veremos a continuación:

>>> time.time()
1424233311.771502

Esta marca de tiempo no tiene en cuenta los segundos bisiestos, por lo que no es lineal; los segundos bisiestos se ignoran. Entonces, si bien no es equivalente al estándar internacional UTC, está cerca y, por lo tanto, es bastante bueno para la mayoría de los casos de mantenimiento de registros.

Sin embargo, esto no es ideal para la programación humana. Si tiene un evento futuro que desea que tenga lugar en un momento determinado, querrá almacenar ese tiempo con una cadena que se pueda analizar en un objeto de fecha y hora o en un objeto de fecha y hora serializado (se describirá más adelante).

time.ctime

También puede representar la hora actual de la manera preferida por su sistema operativo (lo que significa que puede cambiar cuando cambia las preferencias de su sistema, así que no confíe en que esto sea estándar en todos los sistemas, como he visto que otros esperan) . Por lo general, esto es fácil de usar, pero no suele generar cadenas que se puedan ordenar cronológicamente:

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

También puede hidratar marcas de tiempo en forma legible para humanos con ctime:

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

Esta conversión tampoco es buena para el mantenimiento de registros (excepto en el texto que solo será analizado por humanos, y con el reconocimiento óptico de caracteres mejorado y la inteligencia artificial, creo que el número de estos casos disminuirá).

datetime módulo

El datetimemódulo también es bastante útil aquí:

>>> import datetime

datetime.datetime.now

El datetime.nowes un método de clase que devuelve la hora actual. Utiliza la información time.localtimesin la zona horaria (si no se proporciona, de lo contrario, consulte la zona horaria a continuación). Tiene una representación (que le permitiría recrear un objeto equivalente) reflejada en el shell, pero cuando se imprime (o coacciona a str), está en formato legible por humanos (y casi ISO), y el tipo lexicográfico es equivalente al tipo cronológico:

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

fecha y hora utcnow

Puede obtener un objeto datetime en hora UTC, un estándar global, haciendo esto:

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

UTC es un estándar de tiempo que es casi equivalente a la zona horaria GMT. (Si bien GMT y UTC no cambian para el horario de verano, sus usuarios pueden cambiar a otras zonas horarias, como el horario de verano británico, durante el verano).

datetime zona horaria consciente

Sin embargo, ninguno de los objetos de fecha y hora que hemos creado hasta ahora se puede convertir fácilmente a varias zonas horarias. Podemos resolver ese problema con el pytzmódulo:

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

De manera equivalente, en Python 3 tenemos la timezoneclase con una timezoneinstancia de utc adjunta, que también hace que la zona horaria del objeto sea consciente (pero para convertir a otra zona horaria sin el práctico pytzmódulo se deja como ejercicio para el lector):

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

Y vemos que podemos convertir fácilmente a zonas horarias desde el objeto 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

También puede hacer que un objeto datetime ingenuo sea consciente con el método de pytzzona horaria localize, o reemplazando el atributo tzinfo (con replace, esto se hace a ciegas), pero estos son más últimos recursos que mejores prácticas:

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

El pytzmódulo nos permite hacer que nuestros datetimeobjetos conozcan la zona horaria y convertir las horas a los cientos de zonas horarias disponibles en el pytzmódulo.

Una ostensiblemente podría serializar este objeto para la hora UTC y la tienda que en una base de datos, pero requeriría mucho más memoria y ser más propensos a errores que simplemente almacenar la hora Epoch Unix, que demostró por primera vez.

Las otras formas de ver los tiempos son mucho más propensas a errores, especialmente cuando se trata de datos que pueden provenir de diferentes zonas horarias. Desea que no haya confusión sobre a qué zona horaria se destina una cadena o un objeto de fecha y hora serializado.

Si está mostrando la hora con Python para el usuario, ctimefunciona bien, no en una tabla (normalmente no se ordena bien), sino quizás en un reloj. Sin embargo, personalmente recomiendo, cuando se trata de tiempo en Python, ya sea usando tiempo Unix o un datetimeobjeto UTC con reconocimiento de zona horaria .

Hacer

from time import time

t = time()

• t - número flotante, bueno para la medición del intervalo de tiempo.

Hay alguna diferencia para las plataformas Unix y Windows.

>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %X +0000", gmtime())
'Tue, 06 Jan 2009 04:54:56 +0000'

Eso genera el GMT actual en el formato especificado. También hay un localtime()método.

Esta página tiene más detalles.

Las respuestas anteriores son buenas sugerencias, pero me parece más fácil de usar ctime():

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

Esto proporciona una representación de cadena bien formateada de la hora local actual.

La forma más rápida es:

>>> import time
>>> time.strftime("%Y%m%d")
'20130924'

Si necesita la hora actual como un timeobjeto:

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

.isoformat() está en la documentación, pero aún no está aquí (esto es muy similar a la respuesta de @Ray Vega):

>>> import datetime
>>> datetime.datetime.now().isoformat()
'2013-06-24T20:35:55.982000'

¿Por qué no preguntar al Observatorio Naval de los Estados Unidos, el cronometrador oficial de la Marina de los Estados Unidos?

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 vives en el área de DC (como yo), la latencia podría no ser tan mala ...

Usando pandas para obtener la hora actual, exagerando el problema en cuestión:

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)

Salida:

2017-09-22 12:44:56.092642
2017-09-22
2017
9
22
12
44
56
92693

Esto es con lo que terminé yendo:

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

Además, esta tabla es una referencia necesaria para elegir los códigos de formato apropiados para obtener el formato de la fecha tal como lo desea (de la documentación de Python "datetime" aquí ).

si ya está usando numpy, entonces directamente puede usar la función numpy.datetime64 ().

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

por solo fecha:

str(np.datetime64('today'))

o, si ya está usando pandas, puede usar la función pandas.to_datetime ()

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

o,

str(pd.to_datetime('today'))

Puedes usar el timemódulo:

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

>>> 06/02/2015

El uso de la capital Yda el año completo, y el uso ydaría06/02/15 .

También puede usar el siguiente código para dar un tiempo más largo:

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

datetime.now()devuelve la hora actual como un objeto de fecha y hora ingenuo que representa la hora en la zona horaria local. Ese valor puede ser ambiguo, por ejemplo, durante las transiciones DST ("retroceso"). Para evitar ambigüedades, se debe usar la zona horaria UTC:

from datetime import datetime

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

O un objeto compatible con la zona horaria que tiene la información correspondiente de la zona horaria adjunta (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

Do dir(date)o cualquier variable, incluido el paquete. Puede obtener todos los atributos y métodos asociados con la variable.

>>> import datetime, time
>>> time = time.strftime("%H:%M:%S:%MS", time.localtime())
>>> print time
'00:21:38:20S'

Por defecto, la now()función devuelve la salida en el YYYY-MM-DD HH:MM:SS:MSformato. Use el script de muestra a continuación para obtener la fecha y hora actuales en un script de Python e imprimir los resultados en la pantalla. Cree un archivo getDateTime1.pycon el contenido a continuación.

import datetime

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

El resultado se ve a continuación:

2018-03-01 17:03:46.759624

Esta pregunta no necesita una nueva respuesta solo por el hecho de que ... un nuevo juguete / módulo brillante, sin embargo, es suficiente justificación. Esa es la biblioteca de Péndulo , que parece hacer el tipo de cosas que intentaba la flecha, excepto sin los defectos y errores inherentes que acosan a la flecha.

Por ejemplo, la respuesta a la pregunta original:

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

Hay muchos estándares que deben abordarse, incluidos múltiples RFC e ISO, de los que preocuparse. Alguna vez los mezcló; no se preocupe, eche un vistazo adir(pendulum.constants) embargo, Hay un poco más que los formatos RFC e ISO allí.

Cuando decimos local, ¿a qué nos referimos? Bueno, quiero decir:

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

Presumiblemente, la mayoría del resto de ustedes quiere decir en otro lugar.

Y así sigue. Larga historia corta: Pendulum intenta hacer por fecha y hora lo que hicieron las solicitudes de HTTP. Vale la pena considerarlo, especialmente por su facilidad de uso y su extensa documentación.

Hora actual de una zona horaria

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

Pruebe el módulo de flecha de http://crsmithdev.com/arrow/ :

import arrow
arrow.now()

O la versión UTC:

arrow.utcnow()

Para cambiar su salida, agregue .format ():

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

Para una zona horaria específica:

arrow.now('US/Pacific')

Hace una hora:

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

O si quieres la esencia.

arrow.get('2013-05-11T21:23:58.970460+00:00').humanize()
>>> '2 years ago'

Quiero pasar el tiempo con milisegundos. Una forma simple de obtenerlos:

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

Pero solo quiero milisegundos , ¿verdad? La forma más corta de obtenerlos:

import time

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

Agregue o elimine ceros de la última multiplicación para ajustar el número de puntos decimales, o simplemente:

def get_time_str(decimal_points=3):
    return time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 10**decimal_points)

Puede usar esta función para obtener la hora (desafortunadamente no dice AM o PM):

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

Para obtener las horas, minutos, segundos y milisegundos para fusionarse más tarde, puede usar estas funciones:

Hora:

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

Minuto:

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

Segundo:

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

Milisegundo:

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

Si solo desea la marca de tiempo actual en ms (por ejemplo, para medir el tiempo de ejecución), también puede usar el módulo "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))

Porque nadie lo ha mencionado todavía, y esto es algo con lo que me encontré recientemente ... un método fromutc () de la zona horaria pytz combinado con utcnow () de datetime es la mejor manera que he encontrado para obtener una hora (y fecha) útil. en cualquier zona horaria

from datetime import datetime

import pytz


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


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

Si todo lo que quieres es el tiempo, puedes conseguirlo local_time.time().

Lo siguiente es lo que uso para obtener el tiempo sin tener que formatear. A algunas personas no les gusta el método de división, pero es útil aquí:

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

Se imprimirá en formato HH: MM: SS.

Esta pregunta es para Python, pero dado que Django es uno de los frameworks más utilizados para Python, es importante tener en cuenta que si está usando Django, siempre puede usar en timezone.now()lugar de datetime.datetime.now(). El primero es "consciente" de la zona horaria, mientras que el segundo no.

Vea esta respuesta SO y el documento de Django para obtener detalles y justificación timezone.now().

from django.utils import timezone

now = timezone.now()

Puedes hacerlo usando ctime ():

from time import time, ctime
t = time()
ctime(t)

salida:

Sat Sep 14 21:27:08 2019

Estas salidas son diferentes porque la marca de tiempo devuelta por ctime()depende de su ubicación geográfica.