Qual é o módulo / método usado para obter a hora atual?

Usar:

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

E apenas a hora:

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

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

Consulte a documentação para obter mais informações.

Para salvar a digitação, você pode importar o datetimeobjeto do datetimemódulo:

>>> from datetime import datetime

Em seguida, remova a guia datetime.de todas as opções acima.

Você pode 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')

Neste exemplo, a saída será assim: '2013-09-18 11:16:32'

Aqui está a lista de strftimediretivas .

Semelhante à resposta de Harley , mas use a str()função para um formato legível rápido e sujo, um pouco mais humano:

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

Como obtenho a hora atual em Python?

O timemódulo

O timemódulo fornece funções que informam o tempo em "segundos desde a época", bem como outros utilitários.

import time

Hora da época do Unix

Este é o formato no qual você deve obter os carimbos de data e hora para salvar nos bancos de dados. É um número de ponto flutuante simples que pode ser convertido em um número inteiro. Também é bom para aritmética em segundos, pois representa o número de segundos desde 1º de janeiro de 1970 00:00:00 e é luz de memória em relação às outras representações de tempo que veremos a seguir:

>>> time.time()
1424233311.771502

Esse registro de data e hora não conta com segundos bissextos, portanto não é linear - os segundos bissextos são ignorados. Portanto, embora não seja equivalente ao padrão internacional UTC, é próximo e, portanto, bastante bom para a maioria dos casos de manutenção de registros.

Isso não é ideal para agendamento humano, no entanto. Se você tiver um evento futuro que deseja que ocorra em um determinado ponto no tempo, convém armazenar esse tempo com uma sequência que possa ser analisada em um objeto de data e hora ou em um objeto de data e hora serializado (estes serão descritos mais adiante).

time.ctime

Você também pode representar o horário atual da maneira preferida pelo seu sistema operacional (o que significa que ele pode mudar quando você altera as preferências do sistema; portanto, não confie nisso para que seja padrão em todos os sistemas, como já vi outros esperarem) . Isso geralmente é fácil de usar, mas normalmente não resulta em strings que podem ser classificadas cronologicamente:

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

Você também pode hidratar os carimbos de data e hora na forma legível por humanos ctime:

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

Essa conversão também não é boa para manutenção de registros (exceto em textos que serão analisados ​​apenas por humanos - e com o reconhecimento óptico de caracteres e a inteligência artificial aprimorados, acho que o número desses casos diminuirá).

datetime módulo

O datetimemódulo também é bastante útil aqui:

>>> import datetime

datetime.datetime.now

O datetime.nowé um método de classe que retorna a hora atual. Ele usa as informações time.localtimesem o fuso horário (se não for fornecido, consulte o fuso horário ciente abaixo). Ele tem uma representação (que permite recriar um objeto equivalente) ecoado no shell, mas quando impresso (ou coagido a str), ele está no formato legível por humanos (e quase ISO) e o tipo lexicográfico é equivalente ao ordem cronológica:

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

datetime utcnow

Você pode obter um objeto datetime no horário UTC, um padrão global, fazendo o seguinte:

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

UTC é um padrão de tempo que é quase equivalente ao fuso horário GMT. (Enquanto GMT e UTC não mudam para o horário de verão, seus usuários podem mudar para outros fusos horários, como o horário de verão britânico, durante o verão.)

fuso horário datado

No entanto, nenhum dos objetos de data e hora que criamos até agora pode ser facilmente convertido em vários fusos horários. Podemos resolver esse problema com o pytzmódulo:

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

De maneira equivalente, no Python 3, temos a timezoneclasse com uma timezoneinstância utc anexada, o que também torna o fuso horário do objeto ciente (mas a conversão para outro fuso horário sem o pytzmódulo útil é deixada como um exercício para o leitor):

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

E vemos que podemos facilmente converter em fusos horários o 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

Você também pode conscientizar um objeto de data e hora ingênuo com o método de pytzfuso horário localizeou substituindo o atributo tzinfo (por que replaceisso é feito às cegas), mas esses são mais recursos do que práticas recomendadas:

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

O pytzmódulo nos permite datetimeconscientizar o fuso horário de nossos objetos e converter os horários nas centenas de fusos horários disponíveis no pytzmódulo.

Pode-se ostensivamente serializar este objeto para UTC tempo e loja que em um banco de dados, mas isso exigiria muito mais memória e seria mais propenso a erros do que simplesmente armazenar o horário da Unix Epoch, que demonstrei primeiro.

As outras maneiras de visualizar os horários são muito mais propensas a erros, especialmente ao lidar com dados que podem vir de diferentes fusos horários. Você deseja que não haja confusão quanto ao fuso horário em que uma string ou objeto de data e hora serializados foi destinado.

Se você estiver exibindo o horário com Python para o usuário, ctimefuncionará bem, não em uma tabela (normalmente não é bem organizada), mas talvez em um relógio. No entanto, eu pessoalmente recomendo, ao lidar com a hora no Python, usando a hora do Unix ou um datetimeobjeto UTC com reconhecimento de fuso horário .

Faz

from time import time

t = time()

• t - número da bóia, bom para a medição do intervalo de tempo.

Há alguma diferença para as plataformas Unix e Windows.

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

Isso gera o GMT atual no formato especificado. Há também um localtime()método.

Esta página tem mais detalhes.

As respostas anteriores são boas sugestões, mas acho mais fácil usar ctime():

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

Isso fornece uma representação de seqüência de caracteres bem formatada da hora local atual.

A maneira mais rápida é:

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

Se você precisar da hora atual como um timeobjeto:

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

.isoformat() está na documentação, mas ainda não está aqui (isso é bastante semelhante à resposta de @Ray Vega):

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

Por que não perguntar ao Observatório Naval dos EUA , o cronometrista oficial da Marinha dos 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])

Se você mora na área de DC (como eu), a latência pode não ser tão ruim ...

Usando pandas para obter a hora atual, meio que exagere no problema:

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)

Resultado:

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

Isto é o que acabei indo com:

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

Além disso, esta tabela é uma referência necessária para escolher os códigos de formato apropriados para obter a data formatada da maneira que você deseja (da documentação "datetime" do Python aqui ).

se você já estiver usando o numpy, poderá usar diretamente a função numpy.datetime64 ().

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

apenas para data:

str(np.datetime64('today'))

ou, se você já estiver usando pandas, poderá usar a função pandas.to_datetime ()

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

ou,

str(pd.to_datetime('today'))

Você pode usar o timemódulo:

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

>>> 06/02/2015

O uso do capital Ydá o ano inteiro, e o uso ydaria06/02/15 .

Você também pode usar o código a seguir para fornecer um tempo mais longo:

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

datetime.now()retorna a hora atual como um objeto de data e hora ingênuo que representa a hora no fuso horário local. Esse valor pode ser ambíguo, por exemplo, durante transições de horário de verão ("fall back"). Para evitar ambiguidade, o fuso horário UTC deve ser usado:

from datetime import datetime

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

Ou um objeto que reconhece o fuso horário com as informações correspondentes do fuso horário anexadas (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

Faça dir(date)ou quaisquer variáveis, incluindo o pacote. Você pode obter todos os atributos e métodos associados à variável.

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

Por padrão, a now()função retorna a saída no YYYY-MM-DD HH:MM:SS:MSformato. Use o exemplo de script abaixo para obter a data e hora atuais em um script Python e imprimir os resultados na tela. Crie um arquivo getDateTime1.pycom o conteúdo abaixo.

import datetime

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

A saída se parece abaixo:

2018-03-01 17:03:46.759624

Esta questão não precisa de uma nova resposta apenas para o efeito ... um brinquedo / módulo novo e brilhante, no entanto, é justificativa suficiente. Sendo essa a biblioteca Pendulum , que parece fazer o tipo de coisa que a flecha tentou, exceto sem as falhas e os erros inerentes que cercam a flecha.

Por exemplo, a resposta para a pergunta 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

Existem muitos padrões que precisam ser abordados, incluindo vários RFCs e ISOs, com os quais se preocupar. Já os misture; não se preocupe, dê uma olhadadir(pendulum.constants) formatos RFC e ISO, no entanto.

Quando dizemos local, o que queremos dizer? Bem, eu quero dizer:

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

Presumivelmente, a maioria de vocês quer dizer em outro lugar.

E continua. Resumindo: O Pêndulo tenta fazer por data e hora o que os pedidos fizeram pelo HTTP. Vale a pena considerar, principalmente pela facilidade de uso e pela extensa documentação.

Hora atual de um fuso horário

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

Experimente o módulo de seta em http://crsmithdev.com/arrow/ :

import arrow
arrow.now()

Ou a versão UTC:

arrow.utcnow()

Para alterar sua saída, adicione .format ():

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

Para um fuso horário específico:

arrow.now('US/Pacific')

Uma hora atrás:

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

Ou se você quiser a essência.

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

Quero aproveitar o tempo em milissegundos. Uma maneira simples de obtê-los:

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

Mas eu quero apenas milissegundos , certo? A maneira mais curta de obtê-los:

import time

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

Adicione ou remova zeros da última multiplicação para ajustar o número de casas decimais ou apenas:

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

Você pode usar esta função para obter o tempo (infelizmente não diz AM ou PM):

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

Para que as horas, minutos, segundos e milissegundos sejam mesclados posteriormente, você pode usar estas funções:

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]

Milissegundo:

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

Se você deseja apenas o registro de data e hora atual em ms (por exemplo, para medir o tempo de execução), também pode usar o 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))

A seguir, é o que eu uso para obter o tempo sem precisar formatar. Algumas pessoas não gostam do método split, mas é útil aqui:

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

Ele será impresso no formato HH: MM: SS.

Como ninguém o mencionou ainda, e isso é algo que me deparei recentemente ... o método fromutc () de um fuso horário do pytz combinado com o utcnow () do datetime é a melhor maneira que eu encontrei para obter um horário (e data) útil no momento em qualquer fuso horário.

from datetime import datetime

import pytz


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


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

Se tudo o que você quer é o tempo, você pode conseguir isso local_time.time().

Esta pergunta é para o Python, mas como o Django é uma das estruturas mais usadas para o Python, é importante notar que, se você estiver usando o Django, sempre poderá usá-lo em timezone.now()vez de datetime.datetime.now(). O primeiro é o fuso horário "consciente", enquanto o segundo não.

Veja esta resposta do SO e o documento do Django para obter detalhes e justificativa por trás timezone.now().

from django.utils import timezone

now = timezone.now()

Você pode fazer isso usando ctime ():

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

resultado:

Sat Sep 14 21:27:08 2019

Essas saídas são diferentes porque o registro de data e hora retornado ctime()depende da sua localização geográfica.