Convertire un tempo RFC 3339 in un timestamp standard di Python

Question

C'è un modo semplice per convertire un orario RFC 3339 in un normale timestamp Python?

Ho uno script che sta leggendo un feed ATOM e mi piacerebbe essere in grado di confrontare il timestamp di un elemento nel feed ATOM al momento della modifica di un file.

Ho notato dal ATOM spec, che le date di ATOM includono una differenza di fuso orario (Z<a number>), ma, nel mio caso, non c'è niente dopo la Z quindi credo che possiamo supporre GMT.

Suppongo di poter analizzare il tempo con una regex di qualche tipo ma speravo che Python avesse un modo integrato per farlo che non sono stato in grado di trovare.

Answer 1

No builtin, afaik.

feed.date.rfc3339 Questo è un modulo libreria Python con funzioni per la conversione di stringhe in formato timestamp RFC 3339 per valori float tempo Python, e viceversa. RFC 3339 è il formato di timestamp utilizzato dal formato di syndication del feed Atom.

È concesso in licenza BSD.

http://home.blarg.net/~steveha/pyfeed.html

(A cura in modo che sia chiaro che non ho scritto di esso. :-)

Answer 2

http://bugs.python.org/issue15873 (duplicato di http://bugs.python.org/issue5207)

Sembra che non v'è un built-in a partire da ancora.

Answer 3

http://pypi.python.org/pypi/iso8601/ sembra essere in grado di analizzare ISO 8601, che RFC 3339 è un sottoinsieme di, forse questo potrebbe essere utile, ma di nuovo, non integrato.

Answer 4

non si include un esempio, ma se non si dispone di un Z-offset o fuso orario, e supponendo che non si vuole durate, ma solo il tempo di base, allora forse questo fa per voi:

import datetime as dt 
>>> dt.datetime.strptime('1985-04-12T23:20:50.52', '%Y-%m-%dT%H:%M:%S.%f') 
datetime.datetime(1985, 4, 12, 23, 20, 50, 520000) 

La funzione strptime() è stata aggiunta al modulo datetime in Python 2.5, quindi alcune persone non sanno ancora che è lì.

Edit: The time.strptime() la funzione esiste da un po ', però, e lavora circa lo stesso di dare un valore struct_time:

>>> ts = time.strptime('1985-04-12T23:20:50.52', '%Y-%m-%dT%H:%M:%S.%f') 
>>> ts 
time.struct_time(tm_year=1985, tm_mon=4, tm_mday=12, tm_hour=23, tm_min=20, tm_sec=50, tm_wday=4, tm_yday=102, tm_isdst=-1) 
>>> time.mktime(ts) 
482210450.0 

Answer 5

feedparser.py fornisce robusta modo/estendibile per analizzare vari formati di data che si possono incontrare in atomo del mondo reale/RSS: biblioteca

>>> from feedparser import _parse_date as parse_date 
>>> parse_date('1985-04-12T23:20:50.52Z') 
time.struct_time(tm_year=1985, tm_mon=4, tm_mday=12, tm_hour=23, tm_min=20, 
       tm_sec=50, tm_wday=4, tm_yday=102, tm_isdst=1) 

Answer 6

rfc3339: http://henry.precheur.org/python/rfc3339

Answer 7

È venuto attraverso il fantastico modulo dateutil.parser in un'altra domanda, e l'ho provato sul mio problema con RFC3339, e sembra che gestisca tutto ciò con cui lo lancio con maggiore sicurezza rispetto a qualsiasi altra risposta in questa domanda.

Answer 8

provare questo, tutto funziona bene per me

datetime_obj = datetime.strptime("2014-01-01T00:00:00Z", '%Y-%m-%dT%H:%M:%SZ') 

o

datetime_obj = datetime.strptime("Mon, 01 Jun 2015 16:41:40 GMT", '%a, %d %b %Y %H:%M:%S GMT') 

Answer 9

ho lottato con il formato RFC3339 datetime molto, ma ho trovato una soluzione adatta per convertire DATE_STRING < => datetime_object in entrambe le direzioni.

avete bisogno di due diversi moduli esterni, perché uno di loro è è in grado di fare la conversione in una sola direzione (purtroppo):

prima installare:

sudo pip install rfc3339 
sudo pip install iso8601 

quindi includere:

import datetime  # for general datetime object handling 
import rfc3339  # for date object -> date string 
import iso8601  # for date string -> date object 

Per non aver bisogno di ricordare quale modulo è per quale direzione, ho scritto due semplici funzioni di supporto:

def get_date_object(date_string): 
    return iso8601.parse_date(date_string) 

def get_date_string(date_object): 
    return rfc3339.rfc3339(date_object) 

che all'interno del codice è possibile usare facilmente come questo:

input_string = '1989-01-01T00:18:07-05:00' 
test_date = get_date_object(input_string) 
# >>> datetime.datetime(1989, 1, 1, 0, 18, 7, tzinfo=<FixedOffset '-05:00' datetime.timedelta(-1, 68400)>) 

test_string = get_date_string(test_date) 
# >>> '1989-01-01T00:18:07-05:00' 

test_string is input_string # >>> True 

Heureka! Ora si può facilmente (haha ​​) usare le stringhe di data e stringhe di data in un formato utilizzabile.

Answer 10

Utilizzando Python 3, è possibile utilizzare RegEx per interrompere il timestamp di RFC 3339 nei suoi componenti. Poi, crea direttamente l'oggetto datetime, senza moduli aggiuntivi necessari:

import re 
import datetime 

def parse_rfc3339(dt): 
    broken = re.search(r'([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]+))?(Z|([+-][0-9]{2}):([0-9]{2}))', dt) 
    return(datetime.datetime(
     year = int(broken.group(1)), 
     month = int(broken.group(2)), 
     day = int(broken.group(3)), 
     hour = int(broken.group(4)), 
     minute = int(broken.group(5)), 
     second = int(broken.group(6)), 
     microsecond = int(broken.group(8) or "0"), 
     tzinfo = datetime.timezone(datetime.timedelta(
      hours = int(broken.group(10) or "0"), 
      minutes = int(broken.group(11) or "0"))))) 

Questo esempio theads fusi o microsecondi mancante come "0", ma potrebbe essere necessario ulteriore controllo degli errori. Cheers, Alex

Answer 11

Se stai usando Django, è possibile utilizzare di Django funzione parse_datetime:

>>> from django.utils.dateparse import parse_datetime 
>>> parse_datetime("2016-07-19T07:30:36+05:00") 
datetime.datetime(2016, 7, 19, 7, 30, 36, tzinfo=<django.utils.timezone.FixedOffset object at 0x101c0c1d0>)