Преобразование строки даты и времени в формате UTC в локальную дату и время

Если вы не хотите предоставлять свои собственные tzinfo объекты, ознакомьтесь с библиотекой python-dateutil. Он предоставляет tzinfo реализации поверх базы данных zoneinfo (Olson), так что вы можете ссылаться на правила часовых поясов с помощью несколько канонических имя.

from datetime import datetime
from dateutil import tz

# METHOD 1: Hardcode zones:
from_zone = tz.gettz('UTC')
to_zone = tz.gettz('America/New_York')

# METHOD 2: Auto-detect zones:
from_zone = tz.tzutc()
to_zone = tz.tzlocal()

# utc = datetime.utcnow()
utc = datetime.strptime('2011-01-21 02:37:21', '%Y-%m-%d %H:%M:%S')

# Tell the datetime object that it's in UTC time zone since 
# datetime objects are 'naive' by default
utc = utc.replace(tzinfo=from_zone)

# Convert time zone
central = utc.astimezone(to_zone)

Изменить. Пример расширен, чтобы показать strptime использование

Изменить 2. Исправлено использование API, чтобы лучше показать метод точки входа.

Edit 3 Включены методы автоматического определения часовых поясов (Yarin)

Вот устойчивый метод, не зависящий от каких-либо внешних библиотек:

from datetime import datetime
import time

def datetime_from_utc_to_local(utc_datetime):
    now_timestamp = time.time()
    offset = datetime.fromtimestamp(now_timestamp) - datetime.utcfromtimestamp(now_timestamp)
    return utc_datetime + offset

Это позволяет избежать проблем с синхронизацией в примере DelboyJay. И меньшие временные проблемы в поправке Эрика ван Остена.

В качестве интересного примечания, смещение часового пояса, вычисленное выше, может отличаться от следующего, казалось бы, эквивалентного выражения, вероятно, из-за изменений правил перехода на летнее время:

offset = datetime.fromtimestamp(0) - datetime.utcfromtimestamp(0) # NO!

Обновление: недостатком этого фрагмента является использование смещения UTC текущего времени, которое может отличаться от смещения UTC входного datetime. См. Комментарии к этому ответу для другого решения.

Чтобы обойти разные времена, возьмите время эпохи из прошедшего времени. Вот что я делаю:

def utc2local(utc):
    epoch = time.mktime(utc.timetuple())
    offset = datetime.fromtimestamp(epoch) - datetime.utcfromtimestamp(epoch)
    return utc + offset

См. Документацию datetime на tzinfo объектов. Вы должны установить часовые пояса, в которых хотите поддерживать себя. Примеры находятся внизу документации.

Вот простой пример:

from datetime import datetime,tzinfo,timedelta

class Zone(tzinfo):
    def __init__(self,offset,isdst,name):
        self.offset = offset
        self.isdst = isdst
        self.name = name
    def utcoffset(self, dt):
        return timedelta(hours=self.offset) + self.dst(dt)
    def dst(self, dt):
            return timedelta(hours=1) if self.isdst else timedelta(0)
    def tzname(self,dt):
         return self.name

GMT = Zone(0,False,'GMT')
EST = Zone(-5,False,'EST')

print datetime.utcnow().strftime('%m/%d/%Y %H:%M:%S %Z')
print datetime.now(GMT).strftime('%m/%d/%Y %H:%M:%S %Z')
print datetime.now(EST).strftime('%m/%d/%Y %H:%M:%S %Z')

t = datetime.strptime('2011-01-21 02:37:21','%Y-%m-%d %H:%M:%S')
t = t.replace(tzinfo=GMT)
print t
print t.astimezone(EST)

Выход

01/22/2011 21:52:09 
01/22/2011 21:52:09 GMT
01/22/2011 16:52:09 EST
2011-01-21 02:37:21+00:00
2011-01-20 21:37:21-05:00a

Если вы хотите получить правильный результат даже для времени, которое соответствует неоднозначному местному времени (например, во время перехода на летнее время) и / или локальное смещение utc отличается в разное время в вашем местном часовом поясе, используйте pytz часовые пояса:

#!/usr/bin/env python
from datetime import datetime
import pytz    # $ pip install pytz
import tzlocal # $ pip install tzlocal

local_timezone = tzlocal.get_localzone() # get pytz tzinfo
utc_time = datetime.strptime("2011-01-21 02:37:21", "%Y-%m-%d %H:%M:%S")
local_time = utc_time.replace(tzinfo=pytz.utc).astimezone(local_timezone)

Этот ответ должен быть полезен, если вы не хотите использовать какие-либо другие модули, кроме datetime.

datetime.utcfromtimestamp(timestamp) возвращает наивный datetime объект (не осведомленный). Сознательные знают часовой пояс, а наивные - нет. Вам нужен осведомленный, если вы хотите конвертировать между часовыми поясами (например, между UTC и местным временем).

Если вы не тот, кто создает дату для начала, но вы все равно можете создать наивный объект datetime во времени UTC, вы можете попробовать этот код Python 3.x для его преобразования:

import datetime

d=datetime.datetime.strptime("2011-01-21 02:37:21", "%Y-%m-%d %H:%M:%S") #Get your naive datetime object
d=d.replace(tzinfo=datetime.timezone.utc) #Convert it to an aware datetime object in UTC time.
d=d.astimezone() #Convert it to your local timezone (still aware)
print(d.strftime("%d %b %Y (%I:%M:%S:%f %p) %Z")) #Print it with a directive of choice

Будьте осторожны, чтобы не ошибочно предположить, что если ваш часовой пояс в настоящее время - MDT, переход на летнее время не работает с приведенным выше кодом, поскольку он печатает MST. Вы заметите, что если вы измените месяц на август, он напечатает MDT.

Еще один простой способ получить осведомленный объект datetime (также в Python 3.x) - создать его с указанием часового пояса для начала. Вот пример с использованием UTC:

import datetime, sys

aware_utc_dt_obj=datetime.datetime.now(datetime.timezone.utc) #create an aware datetime object
dt_obj_local=aware_utc_dt_obj.astimezone() #convert it to local time

#The following section is just code for a directive I made that I liked.
if sys.platform=="win32":
    directive="%#d %b %Y (%#I:%M:%S:%f %p) %Z"
else:
    directive="%-d %b %Y (%-I:%M:%S:%f %p) %Z"

print(dt_obj_local.strftime(directive))

Если вы используете Python 2.x, вам, вероятно, придется создать подкласс datetime.tzinfo и использовать его для создания осознанного объекта datetime, поскольку datetime.timezone не существует в Python 2.x.

Если вы используете Django, вы можете использовать метод timezone.localtime:

from django.utils import timezone
date 
# datetime.datetime(2014, 8, 1, 20, 15, 0, 513000, tzinfo=<UTC>)

timezone.localtime(date)
# datetime.datetime(2014, 8, 1, 16, 15, 0, 513000, tzinfo=<DstTzInfo 'America/New_York' EDT-1 day, 20:00:00 DST>)

Вы можете использовать стрелку

from datetime import datetime
import arrow

now = datetime.utcnow()

print(arrow.get(now).to('local').format())
# '2018-04-04 15:59:24+02:00'

ты можешь накормить arrow.get() чем угодно. отметка времени, строка iso и т. д.

Объединение ответа из franksands в удобный метод.

import calendar
import datetime

def to_local_datetime(utc_dt):
    """
    convert from utc datetime to a locally aware datetime according to the host timezone

    :param utc_dt: utc datetime
    :return: local timezone datetime
    """
    return datetime.datetime.fromtimestamp(calendar.timegm(utc_dt.timetuple()))

Вы можете использовать calendar.timegm для преобразования времени в секунды с эпохи Unix и time.localtime для обратного преобразования:

import calendar
import time

time_tuple = time.strptime("2011-01-21 02:37:21", "%Y-%m-%d %H:%M:%S")
t = calendar.timegm(time_tuple)

print time.ctime(t)

Дает Fri Jan 21 05:37:21 2011 (потому что я нахожусь в часовом поясе UTC + 03:00).

Я традиционно откладываю это на внешний интерфейс - отправляю время из внутреннего интерфейса в виде отметок времени или в каком-либо другом формате даты и времени в формате UTC, а затем позволяю клиенту определять смещение часового пояса и отображать эти данные в правильном часовом поясе.

Для веб-приложения это довольно просто сделать в javascript - вы можете довольно легко определить смещение часового пояса браузера, используя встроенные методы, а затем правильно отобразить данные из серверной части.

Из ответа здесь вы можете использовать модуль времени для преобразования из utc в местное время, установленное на вашем компьютере:

utc_time = time.strptime("2018-12-13T10:32:00.000", "%Y-%m-%dT%H:%M:%S.%f")
utc_seconds = calendar.timegm(utc_time)
local_time = time.localtime(utc_seconds)

import datetime

def utc_str_to_local_str(utc_str: str, utc_format: str, local_format: str):
    """
    :param utc_str: UTC time string
    :param utc_format: format of UTC time string
    :param local_format: format of local time string
    :return: local time string
    """
    temp1 = datetime.datetime.strptime(utc_str, utc_format)
    temp2 = temp1.replace(tzinfo=datetime.timezone.utc)
    local_time = temp2.astimezone()
    return local_time.strftime(local_format)

utc_tz_example_str = '2018-10-17T00:00:00.111Z'
utc_fmt = '%Y-%m-%dT%H:%M:%S.%fZ'
local_fmt = '%Y-%m-%dT%H:%M:%S+08:00'

# call my function here
local_tz_str = utc_str_to_local_str(utc_tz_example_str, utc_fmt, local_fmt)
print(local_tz_str)   # 2018-10-17T08:00:00+08:00

Когда я ввожу utc_tz_example_str = 2018-10-17T00: 00: 00.111Z, （UTC +00: 00）
, я получаю local_tz_str = 2018-10-17T08: 00 : 00 + 08: 00 （Мой целевой часовой пояс +08: 00）

параметр utc_format - это формат, определяемый вашим конкретным utc_tz_example_str.
параметр local_fmt - это окончательный желаемый формат.

В моем случае желаемый формат - %Y-%m-%dT%H:%M:%S+08:00 (часовой пояс +08: 00). Вы должны создать желаемый формат.

В облачной среде для запада США у меня работало следующее:

import datetime
import pytz

#set the timezone
tzInfo = pytz.timezone('America/Los_Angeles')
dt = datetime.datetime.now(tz=tzInfo)
print(dt)

Вот быстрая и грязная версия, в которой для определения разницы во времени используются настройки локальной системы. ПРИМЕЧАНИЕ. Это не сработает, если вам нужно преобразовать в часовой пояс, в котором ваша текущая система не работает. Я тестировал это с настройками Великобритании в часовом поясе BST.

from datetime import datetime
def ConvertP4DateTimeToLocal(timestampValue):
   assert isinstance(timestampValue, int)

   # get the UTC time from the timestamp integer value.
   d = datetime.utcfromtimestamp( timestampValue )

   # calculate time difference from utcnow and the local system time reported by OS
   offset = datetime.now() - datetime.utcnow()

   # Add offset to UTC time and return it
   return d + offset