Qual é o módulo / método usado para obter a hora atual?
Qual é o módulo / método usado para obter a hora atual?
Respostas:
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 datetime
objeto do datetime
módulo:
>>> from datetime import datetime
Em seguida, remova a guia datetime.
de todas as opções acima.
datetime.datetime.now()
no meu console interativo Python 2.7 (o IronPython ainda não foi atualizado) me dá o mesmo comportamento do exemplo mais recente usado print()
na resposta. Não repliquei com êxito o que a resposta original mostra (datetime.datetime (2009, 1, 6, 15, 8, 24, 78915)). (Não que eu realmente quero, o print () comportamento é o preferido, mas estou curioso.)
datetime.now()
em seu próprio imprime-lo para fora a mesma era como seus programas de resposta print(datetime.now())
...
Você pode usar time.strftime()
:
>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'
time
módulo vs. o datetime
módulo?
localtime()
vez de gmtime()
para obter a hora local.
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 strftime
diretivas .
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?
time
móduloO time
módulo fornece funções que informam o tempo em "segundos desde a época", bem como outros utilitários.
import time
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óduloO datetime
mó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.localtime
sem 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
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.)
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 pytz
mó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 timezone
classe com uma timezone
instâ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 pytz
mó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 pytz
fuso horário localize
ou substituindo o atributo tzinfo (por que replace
isso é 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 pytz
módulo nos permite datetime
conscientizar o fuso horário de nossos objetos e converter os horários nas centenas de fusos horários disponíveis no pytz
mó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, ctime
funcionará 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 datetime
objeto 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'
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 ).
strftime(time_format)
retorna a hora local atual como uma sequência que corresponde à determinada time_format
. Nota: time.strftime()
e datetime.strftime()
suporte a diferentes conjuntos de diretivas, por exemplo, %z
não é suportado time.strftime()
no Python 2 .
time
funções do módulo são invólucros finos em torno das funções C correspondentes. datetime
é um nível mais alto e geralmente é mais portátil.
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 time
módulo:
import time
print time.strftime("%d/%m/%Y")
>>> 06/02/2015
O uso do capital Y
dá o ano inteiro, e o uso y
daria06/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
, então é datetime.datetime.now()
\ n se from datetime import datetime
então édatetime.now()
>>> 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:MS
formato. 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.py
com 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'
arrow.now('Time/Zone')
pode falhar para alguns fusos horários ( arrow
usos dateutil
que tem quebrado UTC -> conversões locais que estão dentro usado arrow.now()
Nota:. pytz
não tem essa questão também,. há outras questões de fuso horário relacionadas
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.