Qual è il modulo / metodo utilizzato per ottenere l'ora corrente?

Uso:

>>> 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 proprio il tempo:

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

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

Vedere la documentazione per ulteriori informazioni.

Per salvare la digitazione, è possibile importare l' datetimeoggetto dal datetimemodulo:

>>> from datetime import datetime

Quindi rimuovere la derivazione datetime.da tutto quanto sopra.

Puoi usare 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')

Per questo esempio, l'output sarà così: '2013-09-18 11:16:32'

Ecco l'elenco delle strftimedirettive .

Simile alla risposta di Harley , ma usa la str()funzione per un formato leggibile rapidamente, leggermente più umano:

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

Come posso ottenere l'ora corrente in Python?

Il timemodulo

Il timemodulo fornisce funzioni che ci indicano il tempo in "secondi dall'epoca" e altre utilità.

import time

Unix Epoch Time

Questo è il formato in cui dovresti ottenere i timestamp per il salvataggio nei database. È un semplice numero in virgola mobile che può essere convertito in un numero intero. È anche buono per l'aritmetica in secondi, poiché rappresenta il numero di secondi dal 1 ° gennaio 1970 alle 00:00:00, ed è la luce della memoria rispetto alle altre rappresentazioni del tempo che vedremo dopo:

>>> time.time()
1424233311.771502

Questo timestamp non tiene conto dei secondi bisestili, quindi non è lineare: i secondi saltati vengono ignorati. Quindi, sebbene non sia equivalente allo standard UTC internazionale, è vicino e quindi abbastanza buono per la maggior parte dei casi di conservazione dei registri.

Questo non è l'ideale per la programmazione umana, tuttavia. Se hai un evento futuro che vorresti aver luogo in un determinato momento, ti consigliamo di archiviarlo con una stringa che può essere analizzata in un oggetto datetime o un oggetto datetime serializzato (questi saranno descritti in seguito).

time.ctime

Puoi anche rappresentare l'ora corrente nel modo preferito dal tuo sistema operativo (il che significa che può cambiare quando cambi le tue preferenze di sistema, quindi non fare affidamento su di esso come standard su tutti i sistemi, come ho visto altri aspettarsi) . Questo è in genere facile da usare, ma in genere non risulta in stringhe che è possibile ordinare in ordine cronologico:

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

Puoi anche idratare i timestamp in una forma leggibile dall'uomo con ctime:

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

Questa conversione non è buona anche per la tenuta dei registri (tranne che nel testo che verrà analizzato solo dagli umani - e con il miglioramento del riconoscimento ottico dei caratteri e dell'intelligenza artificiale, penso che il numero di questi casi diminuirà).

datetime modulo

Il datetimemodulo è anche abbastanza utile qui:

>>> import datetime

datetime.datetime.now

Il datetime.nowè un metodo di classe che restituisce l'ora corrente. Utilizza le informazioni time.localtimesenza fuso orario (se non fornite, altrimenti vedere il fuso orario di seguito). Ha una rappresentazione (che ti consentirebbe di ricreare un oggetto equivalente) echeggiato sulla shell, ma quando stampato (o costretto a un str), è in formato leggibile (e quasi ISO) umano, e l'ordinamento lessicografico è equivalente al ordinamento cronologico:

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

datetime di utcnow

Puoi ottenere un oggetto datetime in tempo UTC, uno standard globale, facendo questo:

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

UTC è uno standard temporale quasi equivalente al fuso orario GMT. (Mentre GMT e UTC non cambiano per l'ora legale, i loro utenti possono passare ad altri fusi orari, come l'ora legale britannica, durante l'estate.)

fuso orario datetime consapevole

Tuttavia, nessuno degli oggetti datetime che abbiamo creato finora può essere facilmente convertito in vari fusi orari. Possiamo risolvere quel problema con il pytzmodulo:

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

Allo stesso modo, in Python 3 abbiamo la timezoneclasse con timezoneun'istanza utc collegata, che rende anche consapevole il fuso orario dell'oggetto (ma per convertire in un altro fuso orario senza il comodo pytzmodulo viene lasciato come esercizio al lettore):

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

E vediamo che possiamo facilmente convertire in fusi orari dall'oggetto utc originale.

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

Puoi anche rendere consapevole un oggetto datetime ingenuo con il metodo del pytzfuso orario localizeo sostituendo l'attributo tzinfo (con replace, questo è fatto alla cieca), ma queste sono più ultime risorse che best practice:

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

Il pytzmodulo ci consente di rendere datetimeconsapevoli i nostri oggetti fuso orario e convertire i tempi in centinaia di fusi orari disponibili nel pytzmodulo.

Si potrebbe apparentemente serializzare questo oggetto per tempo UTC e memorizzare che in un database, ma richiederebbe molto più memoria e più soggetto a errori che semplicemente memorizzare il tempo Unix Epoch, che ho dimostrato prima.

Gli altri modi di visualizzare i tempi sono molto più soggetti a errori, soprattutto quando si tratta di dati che possono provenire da fusi orari diversi. Volete che non ci sia confusione sul fuso orario a cui era destinata una stringa o un oggetto datetime serializzato.

Se stai visualizzando l'ora con Python per l'utente, ctimefunziona bene, non in una tabella (in genere non si ordina bene), ma forse in un orologio. Tuttavia, personalmente consiglio, quando si ha a che fare con il tempo in Python, di usare Unix time o un datetimeoggetto UTC sensibile al fuso orario .

Fare

from time import time

t = time()

• t - numero float, buono per la misurazione dell'intervallo di tempo.

C'è qualche differenza per le piattaforme Unix e Windows.

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

Ciò genera il GMT corrente nel formato specificato. C'è anche un localtime()metodo.

Questa pagina ha maggiori dettagli.

Le risposte precedenti sono tutti buoni suggerimenti, ma trovo che sia più facile da usare ctime():

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

Ciò fornisce una rappresentazione di stringa ben formattata dell'ora locale corrente.

Il modo più veloce è:

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

Se è necessario l'ora corrente come timeoggetto:

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

.isoformat() è nella documentazione, ma non ancora qui (questo è molto simile alla risposta di @Ray Vega):

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

Perché non chiedere all'Osservatorio navale statunitense , il cronometrista ufficiale della Marina degli Stati Uniti?

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 vivi nella zona DC (come me) la latenza potrebbe non essere troppo male ...

Usare i panda per ottenere l'ora corrente, in un certo senso sovraccaricare il 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)

Produzione:

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

Questo è quello che ho finito per andare con:

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

Inoltre, questa tabella è un riferimento necessario per scegliere i codici di formato appropriati per ottenere la data formattata nel modo desiderato (dalla documentazione "datetime" di Python qui ).

se si sta già utilizzando numpy, è possibile utilizzare direttamente la funzione numpy.datetime64 ().

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

per solo data:

str(np.datetime64('today'))

oppure, se stai già utilizzando panda, puoi utilizzare la funzione pandas.to_datetime ()

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

o,

str(pd.to_datetime('today'))

Puoi usare il timemodulo:

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

>>> 06/02/2015

L'uso del capitale Ydà l'intero anno, e l'utilizzo ydarebbe 06/02/15.

Puoi anche usare il seguente codice per avere un tempo più lungo:

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

datetime.now()restituisce l'ora corrente come oggetto datetime ingenuo che rappresenta l'ora nel fuso orario locale. Tale valore può essere ambiguo, ad esempio durante le transizioni dell'ora legale ("fallback"). Per evitare ambiguità, utilizzare il fuso orario UTC:

from datetime import datetime

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

O un oggetto sensibile al fuso orario al quale sono associate le informazioni sul fuso orario corrispondenti (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

Fare dir(date)o qualsiasi variabile incluso il pacchetto. È possibile ottenere tutti gli attributi e i metodi associati alla variabile.

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

Per impostazione predefinita, la now()funzione restituisce l'output nel YYYY-MM-DD HH:MM:SS:MSformato. Utilizzare lo script di esempio seguente per ottenere la data e l'ora correnti in uno script Python e stampare i risultati sullo schermo. Crea un file getDateTime1.pycon il contenuto seguente.

import datetime

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

L'output è simile al seguente:

2018-03-01 17:03:46.759624

Questa domanda non ha bisogno di una nuova risposta solo per il gusto di farlo ... un brillante giocattolo / modulo nuovo, tuttavia, è una giustificazione sufficiente. Essendo la biblioteca del Pendolo , che sembra fare il genere di cose che la freccia ha tentato, tranne senza i difetti e gli insetti intrinseci che assillano la freccia.

Ad esempio, la risposta alla domanda originale:

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

Ci sono molti standard che devono essere affrontati, inclusi RFC e ISO multipli, di cui preoccuparsi. Mai mescolarli; non preoccuparti, dai un'occhiata a dir(pendulum.constants)C'è un po 'più di formati RFC e ISO lì, però.

Quando diciamo locale, ma cosa intendiamo? Bene intendo:

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

Presumibilmente la maggior parte di tutti voi intendete altrove.

E continua così. Per farla breve: Pendulum tenta di fare per data e ora cosa hanno fatto le richieste per HTTP. Vale la pena prendere in considerazione, in particolare sia per la facilità d'uso che per la vasta documentazione.

Ora corrente di un fuso orario

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

Prova il modulo freccia da http://crsmithdev.com/arrow/ :

import arrow
arrow.now()

O la versione UTC:

arrow.utcnow()

Per modificarne l'output, aggiungi .format ():

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

Per un fuso orario specifico:

arrow.now('US/Pacific')

Un'ora fa:

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

O se vuoi l'essenza.

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

Voglio passare il tempo con i millisecondi. Un modo semplice per ottenerli:

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

Ma voglio solo millisecondi , giusto? Il modo più breve per ottenerli:

import time

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

Aggiungi o rimuovi zeri dall'ultima moltiplicazione per regolare il numero di punti decimali o semplicemente:

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

È possibile utilizzare questa funzione per ottenere l'ora (purtroppo non dice AM o PM):

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

Per ottenere ore, minuti, secondi e millisecondi da unire in un secondo momento, è possibile utilizzare queste funzioni:

Ora:

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]

Secondo:

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

millisecond:

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

Se vuoi solo il timestamp corrente in ms (ad esempio, per misurare il tempo di esecuzione), puoi anche usare il modulo "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))

Perché nessuno lo ha ancora menzionato, e questo è qualcosa in cui mi sono imbattuto di recente ... in qualsiasi fuso orario.

from datetime import datetime

import pytz


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


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

Se tutto ciò che vuoi è il tempo, puoi farlo con local_time.time().

Quello che segue è quello che uso per ottenere il tempo senza dover formattare. Ad alcune persone non piace il metodo split, ma è utile qui:

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

Stampa in formato HH: MM: SS.

Questa domanda è per Python ma poiché Django è uno dei framework più utilizzati per Python, è importante notare che se si utilizza Django si può sempre usare al timezone.now()posto di datetime.datetime.now(). Il primo è "consapevole" nel fuso orario, mentre il secondo no.

Vedi questa risposta SO e il documento Django per i dettagli e la logica alla base timezone.now().

from django.utils import timezone

now = timezone.now()

Puoi farlo usando ctime ():

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

produzione:

Sat Sep 14 21:27:08 2019

Questi risultati sono diversi perché il timestamp restituito ctime()dipende dalla posizione geografica.