Wie konvertiere ich eine lokale Zeitzeichenfolge in UTC?

Wie konvertiere ich eine Datums- / Uhrzeitzeichenfolge in Ortszeit in eine Zeichenfolge in UTC-Zeit ?

Ich bin mir sicher, dass ich das schon einmal gemacht habe, kann es aber nicht finden und SO wird mir (und anderen) hoffentlich in Zukunft dabei helfen.

Erläuterung : Wenn ich beispielsweise 2008-09-17 14:02:00in meiner lokalen Zeitzone ( +10) habe, möchte ich eine Zeichenfolge mit der entsprechenden UTCZeit generieren : 2008-09-17 04:02:00.

Beachten Sie außerdem unter http://lucumr.pocoo.org/2011/7/15/eppur-si-muove/ , dass dies im Allgemeinen nicht möglich ist, da bei Sommerzeit und anderen Problemen keine eindeutige Konvertierung von Ortszeit zu erfolgt UTC-Zeit.

Analysieren Sie zunächst die Zeichenfolge in ein naives datetime-Objekt. Dies ist eine Instanz datetime.datetimeohne angehängte Zeitzoneninformationen. Siehe Dokumentation fürdatetime.strptimeInformationen zum Parsen der Datumszeichenfolge finden .

Verwenden Sie die pytz Modul, das eine vollständige Liste der Zeitzonen + UTC enthält. Finden Sie heraus, was die lokale Zeitzone ist, erstellen Sie daraus ein Zeitzonenobjekt und bearbeiten Sie es und hängen Sie es an die naive Datumszeit an.

Schließlich verwenden datetime.astimezone() Methode, um die Datums- und Uhrzeitangabe in UTC zu konvertieren.

Quellcode unter Verwendung der lokalen Zeitzone "America / Los_Angeles" für die Zeichenfolge "2001-2-3 10:11:12":

import pytz, datetime
local = pytz.timezone ("America/Los_Angeles")
naive = datetime.datetime.strptime ("2001-2-3 10:11:12", "%Y-%m-%d %H:%M:%S")
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone(pytz.utc)

Von dort aus können Sie die strftime()Methode verwenden, um die UTC-Datumszeit nach Bedarf zu formatieren:

utc_dt.strftime ("%Y-%m-%d %H:%M:%S")

Mit der Funktion utcnow () des datetime-Moduls kann die aktuelle UTC-Zeit abgerufen werden.

>>> import datetime
>>> utc_datetime = datetime.datetime.utcnow()
>>> utc_datetime.strftime("%Y-%m-%d %H:%M:%S")
'2010-02-01 06:59:19'

Wie der oben von Tom erwähnte Link: http://lucumr.pocoo.org/2011/7/15/eppur-si-muove/ sagt:

UTC ist eine Zeitzone ohne Sommerzeit und dennoch eine Zeitzone ohne Konfigurationsänderungen in der Vergangenheit.

Messen und speichern Sie die Zeit immer in UTC .

Wenn Sie aufzeichnen müssen, wo die Zeit genommen wurde, speichern Sie diese separat. Speichern Sie nicht die Ortszeit + Zeitzoneninformationen!

HINWEIS - Wenn sich Ihre Daten in einer Region befinden, in der die Sommerzeit verwendet wird, verwenden Siepytz die Antwort von John Millikin und sehen Sie sich diese an.

Wenn Sie die UTC-Zeit aus einer bestimmten Zeichenfolge abrufen möchten und das Glück haben, in einer Region auf der Welt zu sein, in der entweder keine Sommerzeit verwendet wird oder Daten nur von der UTC versetzt sind, ohne dass die Sommerzeit angewendet wird:

-> Ortszeit als Basis für den Offsetwert verwenden:

>>> # Obtain the UTC Offset for the current system:
>>> UTC_OFFSET_TIMEDELTA = datetime.datetime.utcnow() - datetime.datetime.now()
>>> local_datetime = datetime.datetime.strptime("2008-09-17 14:04:00", "%Y-%m-%d %H:%M:%S")
>>> result_utc_datetime = local_datetime + UTC_OFFSET_TIMEDELTA
>>> result_utc_datetime.strftime("%Y-%m-%d %H:%M:%S")
'2008-09-17 04:04:00'

-> Oder von einem bekannten Offset mit datetime.timedelta ():

>>> UTC_OFFSET = 10
>>> result_utc_datetime = local_datetime - datetime.timedelta(hours=UTC_OFFSET)
>>> result_utc_datetime.strftime("%Y-%m-%d %H:%M:%S")
'2008-09-17 04:04:00'

AKTUALISIEREN:

Da ist Python 3.2 datetime.timezoneverfügbar. Mit dem folgenden Befehl können Sie ein zeitzonenbewusstes Datum / Uhrzeit-Objekt generieren:

import datetime

timezone_aware_dt = datetime.datetime.now(datetime.timezone.utc)

Wenn Sie bereit sind, Zeitzonen-Konvertierungen vorzunehmen, lesen Sie Folgendes:

https://medium.com/@eleroy/10-things-you-need-to-know-about-date-and-time-in-python-with-datetime-pytz-dateutil-timedelta-309bfbafb3f7

Dank @rofly ist die vollständige Konvertierung von String zu String wie folgt:

time.strftime("%Y-%m-%d %H:%M:%S", 
              time.gmtime(time.mktime(time.strptime("2008-09-17 14:04:00", 
                                                    "%Y-%m-%d %H:%M:%S"))))

Meine Zusammenfassung der time/ calendarFunktionen:

time.strptime
Zeichenfolge -> Tupel (keine Zeitzone angewendet, entspricht also Zeichenfolge)

time.mktime
Ortszeit Tupel -> Sekunden seit der Epoche (immer Ortszeit)

time.gmtime
Sekunden seit der Epoche -> Tupel in UTC

und

calendar.timegm
Tupel in UTC -> Sekunden seit der Epoche

time.localtime
Sekunden seit der Epoche -> Tupel in der lokalen Zeitzone

Hier ist eine Zusammenfassung der gängigen Python-Zeitkonvertierungen.

Einige Methoden lassen Sekundenbruchteile fallen und sind mit (s) gekennzeichnet . Eine explizite Formel, wie ts = (d - epoch) / unitsie stattdessen verwendet werden kann (danke jfs).

• struct_time (UTC) → POSIX (s) :
  calendar.timegm(struct_time)
• Naive Datumszeit (lokal) → POSIX (s) :
  calendar.timegm(stz.localize(dt, is_dst=None).utctimetuple())
  (Ausnahme bei Sommerzeitübergängen, siehe Kommentar von jfs)
• Naive Datumszeit (UTC) → POSIX (s) :
  calendar.timegm(dt.utctimetuple())
• Bewusstes Datum / Uhrzeit → POSIX (s) :
  calendar.timegm(dt.utctimetuple())
• POSIX → struct_time (UTC, s ):
  time.gmtime(t)
  (siehe Kommentar von jfs)
• Naive Datumszeit (lokal) → struct_time (UTC, s ):
  stz.localize(dt, is_dst=None).utctimetuple()
  (Ausnahme bei Sommerzeitübergängen, siehe Kommentar von jfs)
• Naive Datumszeit (UTC) → struct_time (UTC, s ):
  dt.utctimetuple()
• Aware datetime → struct_time (UTC, s ):
  dt.utctimetuple()
• POSIX → Naive Datumszeit (lokal):
  datetime.fromtimestamp(t, None)
  (kann unter bestimmten Bedingungen fehlschlagen, siehe Kommentar von jfs unten)
• struct_time (UTC) → Naive Datumszeit (lokal, s ):
  datetime.datetime(struct_time[:6], tzinfo=UTC).astimezone(tz).replace(tzinfo=None)
  (kann keine darstellen, siehe Kommentar von jfs)
• Naive Datumszeit (UTC) → Naive Datumszeit (lokal):
  dt.replace(tzinfo=UTC).astimezone(tz).replace(tzinfo=None)
• Bewusste Datumszeit → Naive Datumszeit (lokal):
  dt.astimezone(tz).replace(tzinfo=None)
• POSIX → Naive Datumszeit (UTC):
  datetime.utcfromtimestamp(t)
• struct_time (UTC) → Naive Datumszeit (UTC, s ):
  datetime.datetime(*struct_time[:6])
  (kann keine Schaltsekunden darstellen, siehe Kommentar von jfs)
• Naive Datumszeit (lokal) → Naive Datumszeit (UTC):
  stz.localize(dt, is_dst=None).astimezone(UTC).replace(tzinfo=None)
  (Ausnahme bei DST-Übergängen, siehe Kommentar von jfs)
• Bewusste Datumszeit → Naive Datumszeit (UTC):
  dt.astimezone(UTC).replace(tzinfo=None)
• POSIX → Aware datetime:
  datetime.fromtimestamp(t, tz)
  (kann für Nicht-Pytz-Zeitzonen fehlschlagen)
• struct_time (UTC) → Aware datetime (s) :
  datetime.datetime(struct_time[:6], tzinfo=UTC).astimezone(tz)
  (kann keine darstellen, siehe Kommentar von jfs)
• Naive Datumszeit (lokal) → Bewusste Datumszeit:
  stz.localize(dt, is_dst=None)
  (Ausnahme bei Sommerzeitübergängen, siehe Kommentar von jfs)
• Naive Datumszeit (UTC) → Bewusste Datumszeit:
  dt.replace(tzinfo=UTC)

Quelle: taaviburns.ca

def local_to_utc(t):
    secs = time.mktime(t)
    return time.gmtime(secs)

def utc_to_local(t):
    secs = calendar.timegm(t)
    return time.localtime(secs)

Quelle: http://feihonghsu.blogspot.com/2008/02/converting-from-local-time-to-utc.html

Anwendungsbeispiel von bd808 : Wenn Ihre Quelle ein datetime.datetimeObjekt ist t, rufen Sie Folgendes auf :

local_to_utc(t.timetuple())

Ich habe viel Glück mit Dateutil (das auf SO für andere verwandte Fragen allgemein empfohlen wird):

from datetime import *
from dateutil import *
from dateutil.tz import *

# METHOD 1: Hardcode zones:
utc_zone = tz.gettz('UTC')
local_zone = tz.gettz('America/Chicago')
# METHOD 2: Auto-detect zones:
utc_zone = tz.tzutc()
local_zone = tz.tzlocal()

# Convert time string to datetime
local_time = datetime.strptime("2008-09-17 14:02:00", '%Y-%m-%d %H:%M:%S')

# Tell the datetime object that it's in local time zone since 
# datetime objects are 'naive' by default
local_time = local_time.replace(tzinfo=local_zone)
# Convert time to UTC
utc_time = local_time.astimezone(utc_zone)
# Generate UTC time string
utc_string = utc_time.strftime('%Y-%m-%d %H:%M:%S')

(Der Code wurde aus dieser Antwort zum Konvertieren der UTC-Datums- / Uhrzeitzeichenfolge in die lokale Datums- / Uhrzeitangabe abgeleitet. )

Ein weiteres Beispiel mit pytz, enthält aber localize (), was meinen Tag gerettet hat.

import pytz, datetime
utc = pytz.utc
fmt = '%Y-%m-%d %H:%M:%S'
amsterdam = pytz.timezone('Europe/Amsterdam')

dt = datetime.datetime.strptime("2012-04-06 10:00:00", fmt)
am_dt = amsterdam.localize(dt)
print am_dt.astimezone(utc).strftime(fmt)
'2012-04-06 08:00:00'

Ich hatte den größten Erfolg mit Python-Dateutil :

from dateutil import tz

def datetime_to_utc(date):
    """Returns date in UTC w/o tzinfo"""
    return date.astimezone(tz.gettz('UTC')).replace(tzinfo=None) if date.tzinfo else date

import time

import datetime

def Local2UTC(LocalTime):

    EpochSecond = time.mktime(LocalTime.timetuple())
    utcTime = datetime.datetime.utcfromtimestamp(EpochSecond)

    return utcTime

>>> LocalTime = datetime.datetime.now()

>>> UTCTime = Local2UTC(LocalTime)

>>> LocalTime.ctime()

'Thu Feb  3 22:33:46 2011'

>>> UTCTime.ctime()

'Fri Feb  4 05:33:46 2011'

Wenn Sie datetime.datetime bevorzugen:

dt = datetime.strptime("2008-09-17 14:04:00","%Y-%m-%d %H:%M:%S")
utc_struct_time = time.gmtime(time.mktime(dt.timetuple()))
utc_dt = datetime.fromtimestamp(time.mktime(utc_struct_time))
print dt.strftime("%Y-%m-%d %H:%M:%S")

Einfach

Ich habe es so gemacht:

>>> utc_delta = datetime.utcnow()-datetime.now()
>>> utc_time = datetime(2008, 9, 17, 14, 2, 0) + utc_delta
>>> print(utc_time)
2008-09-17 19:01:59.999996

Ausgefallene Implementierung

Wenn Sie Lust haben, können Sie daraus einen Funktor machen:

class to_utc():
    utc_delta = datetime.utcnow() - datetime.now()

    def __call__(cls, t):
        return t + cls.utc_delta

Ergebnis:

>>> utc_converter = to_utc()
>>> print(utc_converter(datetime(2008, 9, 17, 14, 2, 0)))
2008-09-17 19:01:59.999996

Sie können es tun mit:

>>> from time import strftime, gmtime, localtime
>>> strftime('%H:%M:%S', gmtime()) #UTC time
>>> strftime('%H:%M:%S', localtime()) # localtime

Wie wäre es mit -

time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(seconds))

Wenn Sekunden sind None, wird die Ortszeit in UTC-Zeit konvertiert, andernfalls wird die übergebene Zeit in UTC konvertiert.

Um die Sommerzeit usw. zu umgehen

Keine der obigen Antworten hat mir besonders geholfen. Der folgende Code funktioniert für GMT.

def get_utc_from_local(date_time, local_tz=None):
    assert date_time.__class__.__name__ == 'datetime'
    if local_tz is None:
        local_tz = pytz.timezone(settings.TIME_ZONE) # Django eg, "Europe/London"
    local_time = local_tz.normalize(local_tz.localize(date_time))
    return local_time.astimezone(pytz.utc)

import pytz
from datetime import datetime

summer_11_am = datetime(2011, 7, 1, 11)
get_utc_from_local(summer_11_am)
>>>datetime.datetime(2011, 7, 1, 10, 0, tzinfo=<UTC>)

winter_11_am = datetime(2011, 11, 11, 11)
get_utc_from_local(winter_11_am)
>>>datetime.datetime(2011, 11, 11, 11, 0, tzinfo=<UTC>)

Verwenden von http://crsmithdev.com/arrow/

arrowObj = arrow.Arrow.strptime('2017-02-20 10:00:00', '%Y-%m-%d %H:%M:%S' , 'US/Eastern')

arrowObj.to('UTC') or arrowObj.to('local') 

Diese Bibliothek macht das Leben einfach :)

Ich habe hier die beste Antwort auf eine andere Frage gefunden . Es werden nur in Python integrierte Bibliotheken verwendet, und Sie müssen keine lokale Zeitzone eingeben (in meinem Fall eine Anforderung).

import time
import calendar

local_time = time.strptime("2018-12-13T09:32:00.000", "%Y-%m-%dT%H:%M:%S.%f")
local_seconds = time.mktime(local_time)
utc_time = time.gmtime(local_seconds)

Ich poste die Antwort hier erneut, da diese Frage in Google anstelle der verknüpften Frage in Abhängigkeit von den Suchbegriffen angezeigt wird.

Ich habe diesen Code in einem meiner Projekte:

from datetime import datetime
## datetime.timezone works in newer versions of python
try:
    from datetime import timezone
    utc_tz = timezone.utc
except:
    import pytz
    utc_tz = pytz.utc

def _to_utc_date_string(ts):
    # type (Union[date,datetime]]) -> str
    """coerce datetimes to UTC (assume localtime if nothing is given)"""
    if (isinstance(ts, datetime)):
        try:
            ## in python 3.6 and higher, ts.astimezone() will assume a
            ## naive timestamp is localtime (and so do we)
            ts = ts.astimezone(utc_tz)
        except:
            ## in python 2.7 and 3.5, ts.astimezone() will fail on
            ## naive timestamps, but we'd like to assume they are
            ## localtime
            import tzlocal
            ts = tzlocal.get_localzone().localize(ts).astimezone(utc_tz)
    return ts.strftime("%Y%m%dT%H%M%SZ")

In Python3:

pip install python-dateutil

from dateutil.parser import tz

mydt.astimezone(tz.gettz('UTC')).replace(tzinfo=None) 

Wie wäre es mit -

time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(seconds))

Wenn Sekunden sind None, wird die Ortszeit in UTC-Zeit konvertiert, andernfalls wird die übergebene Zeit in UTC konvertiert.