Convertire un datetime UTC di Python in un datetime locale usando solo la libreria standard di Python?

Ho un'istanza datetime python che è stata creata usando datetime.utcnow () e persistente nel database.

Per la visualizzazione, vorrei convertire l'istanza del datetime recuperata dal database in datetime locale utilizzando il fuso orario locale predefinito (ovvero, come se il datetime fosse stato creato utilizzando datetime.now ()).

Come posso convertire il datetime UTC in un datetime locale usando solo la libreria standard di Python (es. Nessuna dipendenza pytz)?

Sembra che una soluzione sarebbe usare datetime.astimezone (tz), ma come otterresti il ​​fuso orario locale predefinito?

In Python 3.3+:

from datetime import datetime, timezone

def utc_to_local(utc_dt):
    return utc_dt.replace(tzinfo=timezone.utc).astimezone(tz=None)

In Python 2/3:

import calendar
from datetime import datetime, timedelta

def utc_to_local(utc_dt):
    # get integer timestamp to avoid precision lost
    timestamp = calendar.timegm(utc_dt.timetuple())
    local_dt = datetime.fromtimestamp(timestamp)
    assert utc_dt.resolution >= timedelta(microseconds=1)
    return local_dt.replace(microsecond=utc_dt.microsecond)

Utilizzando pytz(entrambi Python 2/3):

import pytz

local_tz = pytz.timezone('Europe/Moscow') # use your local timezone name here
# NOTE: pytz.reference.LocalTimezone() would produce wrong result here

## You could use `tzlocal` module to get local timezone on Unix and Win32
# from tzlocal import get_localzone # $ pip install tzlocal

# # get local timezone    
# local_tz = get_localzone()

def utc_to_local(utc_dt):
    local_dt = utc_dt.replace(tzinfo=pytz.utc).astimezone(local_tz)
    return local_tz.normalize(local_dt) # .normalize might be unnecessary

Esempio

def aslocaltimestr(utc_dt):
    return utc_to_local(utc_dt).strftime('%Y-%m-%d %H:%M:%S.%f %Z%z')

print(aslocaltimestr(datetime(2010,  6, 6, 17, 29, 7, 730000)))
print(aslocaltimestr(datetime(2010, 12, 6, 17, 29, 7, 730000)))
print(aslocaltimestr(datetime.utcnow()))

Produzione

2010-06-06 21:29:07.730000 MSD+0400
2010-12-06 20:29:07.730000 MSK+0300
2012-11-08 14:19:50.093745 MSK+0400

2010-06-06 21:29:07.730000 
2010-12-06 20:29:07.730000 
2012-11-08 14:19:50.093911 

2010-06-06 21:29:07.730000 MSD+0400
2010-12-06 20:29:07.730000 MSK+0300
2012-11-08 14:19:50.146917 MSK+0400

Nota: tiene conto dell'ora legale e della recente modifica dell'offset utc per il fuso orario MSK.

Non so se le soluzioni non pytz funzionano su Windows.

Non puoi farlo solo con la libreria standard poiché la libreria standard non ha fusi orari. Hai bisogno di Pytz o Dateutil .

>>> from datetime import datetime
>>> now = datetime.utcnow()
>>> from dateutil import tz
>>> HERE = tz.tzlocal()
>>> UTC = tz.gettz('UTC')

The Conversion:
>>> gmt = now.replace(tzinfo=UTC)
>>> gmt.astimezone(HERE)
datetime.datetime(2010, 12, 30, 15, 51, 22, 114668, tzinfo=tzlocal())

O bene, puoi farlo senza pytz o dateutil implementando i tuoi fusi orari. Ma sarebbe sciocco.

Non puoi farlo con la libreria standard. Utilizzando il modulo pytz è possibile convertire qualsiasi oggetto datetime ingenuo / consapevole in qualsiasi altro fuso orario. Vediamo alcuni esempi usando Python 3.

Oggetti ingenui creati con il metodo class utcnow()

Per convertire un oggetto ingenuo in qualsiasi altro fuso orario, devi prima convertirlo in un oggetto datetime consapevole . È possibile utilizzare il replacemetodo per convertire un oggetto datetime ingenuo in un oggetto datetime consapevole . Quindi per convertire un oggetto datetime consapevole in qualsiasi altro fuso orario puoi usare il astimezonemetodo.

La variabile pytz.all_timezonesfornisce l'elenco di tutti i fusi orari disponibili nel modulo pytz.

import datetime,pytz

dtobj1=datetime.datetime.utcnow()   #utcnow class method
print(dtobj1)

dtobj3=dtobj1.replace(tzinfo=pytz.UTC) #replace method

dtobj_hongkong=dtobj3.astimezone(pytz.timezone("Asia/Hong_Kong")) #astimezone method
print(dtobj_hongkong)

Oggetti ingenui creati con il metodo class now()

Poiché il nowmetodo restituisce la data e l'ora correnti, è necessario rendere prima consapevole il fuso orario dell'oggetto datetime. La localize funzione converte un oggetto datetime ingenuo in un oggetto datetime sensibile al fuso orario. Quindi è possibile utilizzare il astimezonemetodo per convertirlo in un altro fuso orario.

dtobj2=datetime.datetime.now()

mytimezone=pytz.timezone("Europe/Vienna") #my current timezone
dtobj4=mytimezone.localize(dtobj2)        #localize function

dtobj_hongkong=dtobj4.astimezone(pytz.timezone("Asia/Hong_Kong")) #astimezone method
print(dtobj_hongkong)

Penso di averlo capito: calcola il numero di secondi dall'epoca, quindi si converte in un timzeone locale usando time.localtime, e quindi converte la struttura temporale in un datetime ...

EPOCH_DATETIME = datetime.datetime(1970,1,1)
SECONDS_PER_DAY = 24*60*60

def utc_to_local_datetime( utc_datetime ):
    delta = utc_datetime - EPOCH_DATETIME
    utc_epoch = SECONDS_PER_DAY * delta.days + delta.seconds
    time_struct = time.localtime( utc_epoch )
    dt_args = time_struct[:6] + (delta.microseconds,)
    return datetime.datetime( *dt_args )

Si applica correttamente l'ora legale estate / inverno:

>>> utc_to_local_datetime( datetime.datetime(2010, 6, 6, 17, 29, 7, 730000) )
datetime.datetime(2010, 6, 6, 19, 29, 7, 730000)
>>> utc_to_local_datetime( datetime.datetime(2010, 12, 6, 17, 29, 7, 730000) )
datetime.datetime(2010, 12, 6, 18, 29, 7, 730000)

Basandosi sul commento di Alexei. Questo dovrebbe funzionare anche per l'ora legale.

import time
import datetime

def utc_to_local(dt):
    if time.localtime().tm_isdst:
        return dt - datetime.timedelta(seconds = time.altzone)
    else:
        return dt - datetime.timedelta(seconds = time.timezone)

La libreria Python standard non include alcuna tzinfoimplementazione. Ho sempre considerato questo un difetto sorprendente del modulo datetime.

La documentazione per la classe tzinfo contiene alcuni esempi utili. Cerca il grande blocco di codice alla fine della sezione.

Python 3.9 aggiunge il zoneinfomodulo così ora può essere fatto come segue (solo stdlib):

from zoneinfo import ZoneInfo
from datetime import datetime

utc_unaware = datetime(2020, 10, 31, 12)  # loaded from database
utc_aware = utc_unaware.replace(tzinfo=ZoneInfo('UTC'))  # make aware
local_aware = utc_aware.astimezone(ZoneInfo('localtime'))  # convert

L'Europa centrale è 1 o 2 ore avanti rispetto a UTC, quindi local_awareè:

datetime.datetime(2020, 10, 31, 13, 0, tzinfo=backports.zoneinfo.ZoneInfo(key='localtime'))

come str:

2020-10-31 13:00:00+01:00

Windows non ha un database di fuso orario di sistema, quindi qui è necessario un pacchetto aggiuntivo:

pip install tzdata  

Esiste un backport per consentire l'uso in Python da 3.6 a 3.8 :

sudo pip install backports.zoneinfo

Poi:

from backports.zoneinfo import ZoneInfo

Un modo semplice (ma forse imperfetto) che funziona in Python 2 e 3:

import time
import datetime

def utc_to_local(dt):
    return dt - datetime.timedelta(seconds = time.timezone)

Il suo vantaggio è che è banale scrivere una funzione inversa

Il modo più semplice che ho trovato è quello di ottenere la differenza di orario di dove ti trovi , quindi sottrarlo da un'ora.

def format_time(ts,offset):
    if not ts.hour >= offset:
        ts = ts.replace(day=ts.day-1)
        ts = ts.replace(hour=ts.hour-offset)
    else:
        ts = ts.replace(hour=ts.hour-offset)
    return ts

Questo funziona per me, in Python 3.5.2.

Ecco un altro modo per cambiare il fuso orario nel formato datetime (so di aver sprecato la mia energia in questo, ma non ho visto questa pagina quindi non so come) senza min. e sec. perché non ne ho bisogno per il mio progetto:

def change_time_zone(year, month, day, hour):
      hour = hour + 7 #<-- difference
      if hour >= 24:
        difference = hour - 24
        hour = difference
        day += 1
        long_months = [1, 3, 5, 7, 8, 10, 12]
        short_months = [4, 6, 9, 11]
        if month in short_months:
          if day >= 30:
            day = 1
            month += 1
            if month > 12:
              year += 1
        elif month in long_months:
          if day >= 31:
            day = 1
            month += 1
            if month > 12:
              year += 1
        elif month == 2:
          if not year%4==0:
            if day >= 29:
              day = 1
              month += 1
              if month > 12:
                year += 1
          else:
            if day >= 28:
              day = 1
              month += 1
              if month > 12:
                year += 1
      return datetime(int(year), int(month), int(day), int(hour), 00)

Questo è un modo terribile per farlo, ma evita di creare una definizione. Soddisfa il requisito di attenersi alla libreria Python3 di base.

# Adjust from UST to Eastern Standard Time (dynamic)
# df.my_localtime should already be in datetime format, so just in case
df['my_localtime'] = pd.to_datetime.df['my_localtime']

df['my_localtime'] = df['my_localtime'].dt.tz_localize('UTC').dt.tz_convert('America/New_York').astype(str)
df['my_localtime'] = pd.to_datetime(df.my_localtime.str[:-6])

Utilizzare timedelta per alternare i fusi orari. Tutto ciò che serve è l'offset in ore tra i fusi orari. Non è necessario giocherellare con i limiti per tutti e 6 gli elementi di un oggetto datetime. timedelta gestisce facilmente anni bisestili, secoli bisestili, ecc. Devi prima

from datetime import datetime, timedelta

Quindi se offsetè il delta del fuso orario in ore:

timeout = timein + timedelta(hours = offset)

dove timein e timeout sono oggetti datetime. per esempio

timein + timedelta(hours = -8)

converte da GMT a PST.

Quindi, come determinare offset? Ecco una semplice funzione a patto che tu abbia solo poche possibilità di conversione senza usare oggetti datetime che sono "consapevoli" del fuso orario che alcune altre risposte fanno bene. Un po 'manuale, ma a volte la chiarezza è la cosa migliore.

def change_timezone(timein, timezone, timezone_out):
    '''
    changes timezone between predefined timezone offsets to GMT
    timein - datetime object
    timezone - 'PST', 'PDT', 'GMT' (can add more as needed)
    timezone_out - 'PST', 'PDT', 'GMT' (can add more as needed)
    ''' 
    # simple table lookup        
    tz_offset =  {'PST': {'GMT': 8, 'PDT': 1, 'PST': 0}, \
                  'GMT': {'PST': -8, 'PDT': -7, 'GMT': 0}, \
                  'PDT': {'GMT': 7, 'PST': -1, 'PDT': 0}}
    try:
        offset = tz_offset[timezone][timezone_out]
    except:
        msg = 'Input timezone=' + timezone + ' OR output time zone=' + \
            timezone_out + ' not recognized'
        raise DateTimeError(msg)

    return timein + timedelta(hours = offset)

Dopo aver esaminato le numerose risposte e aver giocato con il codice più stretto che mi viene in mente (per ora), sembra che tutte le applicazioni, dove il tempo è importante e i fusi orari misti devono essere considerati, dovrebbero fare uno sforzo reale per realizzare tutti gli oggetti datetime "consapevole". Quindi sembrerebbe che la risposta più semplice sia:

timeout = timein.astimezone(pytz.timezone("GMT"))

per convertire in GMT, ad esempio. Naturalmente, per convertire in / da qualsiasi altro fuso orario desiderato, locale o di altro tipo, basta usare la stringa di fuso orario appropriata che pytz comprende (da pytz.all_timezones). Viene quindi presa in considerazione anche l'ora legale.