datetime — Основные типы даты и времени

Объекты с часовым поясом и без него

Объекты даты и времени можно классифицировать как «с часовым поясом» или «без часового пояса» в зависимости от того, содержат ли они информацию о часовом поясе.

Обладая достаточными сведениями о применимых алгоритмических и политических изменениях времени, например о часовом поясе и переходе на летнее время, объект с часовым поясом может определить своё положение относительно других объектов с часовым поясом. Такой объект представляет конкретный момент времени, не допускающий неоднозначной интерпретации. [1]

Объект без часового пояса не содержит достаточно информации, чтобы однозначно определить своё положение относительно других объектов даты и времени. Представляет ли такой объект всемирное координированное время (UTC), местное время или время в каком-либо другом часовом поясе, полностью зависит от программы, так же как от программы зависит, обозначает ли конкретное число метры, мили или массу. Объекты без часового пояса понятны и просты в использовании, но за это приходится платить игнорированием некоторых аспектов реальности.

Для приложений, которым нужны объекты с часовым поясом, объекты datetime и time имеют необязательный атрибут информации о часовом поясе tzinfo, которому можно присвоить экземпляр подкласса абстрактного класса tzinfo. Эти объекты tzinfo содержат сведения о смещении относительно UTC, названии часового пояса и о том, действует ли летнее время.

Модуль datetime предоставляет только один конкретный класс tzinfo — класс timezone. Класс timezone может представлять простые часовые пояса с фиксированным смещением относительно UTC, например сам UTC или североамериканские часовые пояса EST и EDT. Поддержка часовых поясов с более подробными правилами остаётся на усмотрение приложения. Правила изменения времени по всему миру скорее политические, чем рациональные, часто меняются, и, кроме UTC, не существует стандарта, подходящего для всех приложений.

Константы

Модуль datetime экспортирует следующие константы:

datetime.MINYEAR

Наименьший номер года, допустимый в объекте date или datetime. Значение MINYEAR равно 1.

datetime.MAXYEAR

Наибольший номер года, допустимый в объекте date или datetime. Значение MAXYEAR равно 9999.

datetime.UTC

Псевдоним одиночного объекта часового пояса UTC datetime.timezone.utc.

Добавлено в версии 3.11.

Доступные типы

class datetime.date

Идеализированная дата без часового пояса, предполагающая, что действующий григорианский календарь всегда был и всегда будет в силе. Атрибуты: year, month и day.

class datetime.time

Идеализированное время, не зависящее от конкретного дня, при условии, что в каждом дне ровно 24*60*60 секунд. (Понятия «високосной секунды» здесь нет.) Атрибуты: hour, minute, second, microsecond и tzinfo.

class datetime.datetime

Сочетание даты и времени. Атрибуты: year, month, day, hour, minute, second, microsecond и tzinfo.

class datetime.timedelta

Длительность, выражающая разницу между двумя экземплярами datetime или date с точностью до микросекунды.

class datetime.tzinfo

Абстрактный базовый класс для объектов с информацией о часовом поясе. Классы datetime и time используют такие объекты, чтобы обеспечить настраиваемое представление изменения времени (например, для учёта часового пояса и/или перехода на летнее время).

class datetime.timezone

Класс, реализующий абстрактный базовый класс tzinfo как фиксированное смещение относительно UTC.

Добавлено в версии 3.2.

Объекты этих типов неизменяемы.

Отношения наследования:

object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime

Объекты timedelta

Объект timedelta представляет длительность — разницу между двумя экземплярами datetime или date.

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

Все аргументы необязательны и по умолчанию равны 0. Аргументы могут быть целыми числами или числами с плавающей точкой, положительными или отрицательными.

Внутренне хранятся только дни, секунды и микросекунды. Аргументы преобразуются в эти единицы:

• Миллисекунда преобразуется в 1000 микросекунд.
• Минута преобразуется в 60 секунд.
• Час преобразуется в 3600 секунд.
• Неделя преобразуется в 7 дней.

Затем дни, секунды и микросекунды нормализуются так, чтобы представление было единственным, при этом

• 0 <= microseconds < 1000000
• 0 <= seconds < 3600*24 (число секунд в сутках)
• -999999999 <= days <= 999999999

В следующем примере показано, как все аргументы, кроме days, seconds и microseconds, «объединяются» и нормализуются в эти три итоговых атрибута:

>>> from datetime import timedelta
>>> delta = timedelta(
...     days=50,
...     seconds=27,
...     microseconds=10,
...     milliseconds=29000,
...     minutes=5,
...     hours=8,
...     weeks=2
... )
>>> # Only days, seconds, and microseconds remain
>>> delta
datetime.timedelta(days=64, seconds=29156, microseconds=10)

Если какой-либо аргумент является числом с плавающей точкой и в результате остаются дробные микросекунды, дробные микросекунды, полученные из всех аргументов, складываются, а их сумма округляется до ближайшей микросекунды; при равенстве округление выполняется до ближайшего чётного числа. Если ни один аргумент не является числом с плавающей точкой, преобразование и нормализация выполняются точно (информация не теряется).

Если нормализованное значение дней выходит за указанный диапазон, возникает исключение OverflowError.

Обратите внимание, что нормализация отрицательных значений поначалу может показаться неожиданной. Например:

>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
(-1, 86399, 999999)

Атрибуты класса:

timedelta.min

Наиболее отрицательный объект timedelta, timedelta(-999999999).

timedelta.max

Наиболее положительный объект timedelta, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999).

timedelta.resolution

Наименьшая возможная разница между неравными объектами timedelta, timedelta(microseconds=1).

Обратите внимание, что из-за нормализации timedelta.max больше, чем -timedelta.min. -timedelta.max нельзя представить в виде объекта timedelta.

Атрибуты экземпляра (только для чтения):

timedelta.days

От -999 999 999 до 999 999 999 включительно.

timedelta.seconds

От 0 до 86 399 включительно.

Предупреждение

Довольно часто код по ошибке использует этот атрибут, хотя на самом деле требуется получить значение total_seconds():

>>> from datetime import timedelta
>>> duration = timedelta(seconds=11235813)
>>> duration.days, duration.seconds
(130, 3813)
>>> duration.total_seconds()
11235813.0

timedelta.microseconds

От 0 до 999 999 включительно.

Поддерживаемые операции:

Примечания:

1. Операция точна, но может вызвать переполнение.
2. Операция точна и не может вызвать переполнение.
3. Деление на ноль вызывает исключение ZeroDivisionError.
4. -timedelta.max нельзя представить в виде объекта timedelta.

5. Строковые представления объектов timedelta нормализуются так же, как их внутреннее представление. Из-за этого результаты для отрицательных timedelta могут быть несколько необычными. Например:

   >>> timedelta(hours=-5)
   datetime.timedelta(days=-1, seconds=68400)
   >>> print(_)
   -1 day, 19:00:00
   

6. Выражение t2 - t3 всегда будет равно выражению t2 + (-t3), кроме случая, когда t3 равно timedelta.max; в этом случае первое выражение вернёт результат, а второе вызовет переполнение.

Помимо перечисленных выше операций, объекты timedelta поддерживают некоторые операции сложения и вычитания с объектами date и datetime (см. ниже).

Для объектов timedelta поддерживаются сравнения на равенство и порядок.

В логическом контексте объект timedelta считается истинным тогда и только тогда, когда он не равен timedelta(0).

Методы экземпляра:

timedelta.total_seconds()

Возвращает общее количество секунд в длительности. Эквивалентно td / timedelta(seconds=1). Для единиц интервала, отличных от секунд, используйте непосредственно операцию деления (например, td / timedelta(microseconds=1)).

Обратите внимание, что для очень больших интервалов времени (более 270 лет на большинстве платформ) этот метод теряет точность до микросекунд.

Добавлено в версии 3.2.

>>> # Components of another_year add up to exactly 365 days
>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)
>>> year == another_year
True
>>> year.total_seconds()
31536000.0

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> ten_years = 10 * year
>>> ten_years
datetime.timedelta(days=3650)
>>> ten_years.days // 365
10
>>> nine_years = ten_years - year
>>> nine_years
datetime.timedelta(days=3285)
>>> three_years = nine_years // 3
>>> three_years, three_years.days // 365
(datetime.timedelta(days=1095), 3)

Объекты date

Объект date представляет дату (год, месяц и день) в идеализированном календаре — григорианском календаре, расширенном на неопределённое время в обоих направлениях.

1 января года 1 называется днём номер 1, 2 января года 1 называется днём номер 2 и так далее. [2]

class datetime.date(year, month, day)

Все аргументы обязательны. Аргументы должны быть целыми числами в следующих диапазонах:

• MINYEAR <= year <= MAXYEAR
• 1 <= month <= 12
• 1 <= day <= number of days in the given month and year

Если задан аргумент, выходящий за пределы этих диапазонов, возбуждается исключение ValueError.

Другие конструкторы, все являются методами класса:

classmethod date.today()

Возвращает текущую местную дату.

Эквивалентно date.fromtimestamp(time.time()).

classmethod date.fromtimestamp(timestamp)

Возвращает местную дату, соответствующую метке времени POSIX, например возвращаемой time.time().

Может возбудить исключение OverflowError, если метка времени выходит за пределы диапазона значений, поддерживаемых функцией localtime() языка C на платформе, и OSError в случае ошибки localtime(). Обычно допустимый диапазон ограничен годами с 1970 по 2038. Обратите внимание, что в системах, отличных от POSIX, в которых метка времени учитывает високосные секунды, метод fromtimestamp() игнорирует високосные секунды.

Изменено в версии 3.3: Если метка времени выходит за пределы диапазона значений, поддерживаемых функцией localtime() языка C на платформе, вместо ValueError возбуждается исключение OverflowError. В случае ошибки localtime() вместо ValueError возбуждается исключение OSError.

classmethod date.fromordinal(ordinal)

Возвращает дату, соответствующую пролептическому григорианскому порядковому номеру, в котором 1 января года 1 имеет номер 1.

Если 1 <= ordinal <= date.max.toordinal() не выполняется, возбуждается исключение ValueError. Для любой даты d выполняется date.fromordinal(d.toordinal()) == d.

classmethod date.fromisoformat(date_string)

Возвращает объект date, соответствующий строке date_string, заданной в любом допустимом формате ISO 8601, за следующими исключениями:

1. Даты с пониженной точностью пока не поддерживаются (YYYY-MM, YYYY).
2. Расширенные представления дат пока не поддерживаются (±YYYYYY-MM-DD).
3. Порядковые даты пока не поддерживаются (YYYY-OOO).

Примеры:

>>> from datetime import date
>>> date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)
>>> date.fromisoformat('20191204')
datetime.date(2019, 12, 4)
>>> date.fromisoformat('2021-W01-1')
datetime.date(2021, 1, 4)

Добавлено в версии 3.7.

Изменено в версии 3.11: Ранее этот метод поддерживал только формат YYYY-MM-DD.

classmethod date.fromisocalendar(year, week, day)

Возвращает объект date, соответствующий дате ISO-календаря, заданной годом, неделей и днём. Это обратная функция к date.isocalendar().

Добавлено в версии 3.8.

Атрибуты класса:

date.min

Самая ранняя представимая дата: date(MINYEAR, 1, 1).

date.max

Самая поздняя представимая дата: date(MAXYEAR, 12, 31).

date.resolution

Наименьшая возможная разница между различными объектами даты: timedelta(days=1).

Атрибуты экземпляра (только для чтения):

date.year

От MINYEAR до MAXYEAR включительно.

date.month

От 1 до 12 включительно.

date.day

От 1 до количества дней в указанном месяце указанного года.

Поддерживаемые операции:

Примечания:

1. date2 перемещается вперёд во времени, если timedelta.days > 0, или назад, если timedelta.days < 0. После этого date2 - date1 == timedelta.days. timedelta.seconds и timedelta.microseconds игнорируются. Если date2.year окажется меньше MINYEAR или больше MAXYEAR, возбуждается исключение OverflowError.
2. timedelta.seconds и timedelta.microseconds игнорируются.
3. Результат точен, переполнение невозможно. timedelta.seconds и timedelta.microseconds равны 0, а date2 + timedelta == date1 после.
4. Объекты date равны, если представляют одну и ту же дату.
5. date1 считается меньшей, чем date2, если date1 предшествует date2 во времени. Иными словами, date1 < date2 тогда и только тогда, когда date1.toordinal() < date2.toordinal().

В логическом контексте все объекты date считаются истинными.

Методы экземпляра:

date.replace(year=self.year, month=self.month, day=self.day)

Возвращает дату с тем же значением, за исключением параметров, которым присваиваются новые значения указанными аргументами-ключевыми словами.

Пример:

>>> from datetime import date
>>> d = date(2002, 12, 31)
>>> d.replace(day=26)
datetime.date(2002, 12, 26)

date.timetuple()

Возвращает объект time.struct_time, аналогичный возвращаемому time.localtime().

Часы, минуты и секунды равны 0, флаг летнего времени равен -1.

d.timetuple() эквивалентно:

time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))

где yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 — номер дня в текущем году, начиная с 1 для 1 января.

date.toordinal()

Возвращает пролептический григорианский порядковый номер даты, в котором 1 января года 1 имеет номер 1. Для любого объекта date d выполняется date.fromordinal(d.toordinal()) == d.

date.weekday()

Возвращает день недели в виде целого числа: понедельник — 0, воскресенье — 6. Например, date(2002, 12, 4).weekday() == 2 — среда. См. также isoweekday().

date.isoweekday()

Возвращает день недели в виде целого числа: понедельник — 1, воскресенье — 7. Например, date(2002, 12, 4).isoweekday() == 3 — среда. См. также weekday(), isocalendar().

date.isocalendar()

Возвращает объект именованного кортежа с тремя компонентами: year, week и weekday.

Календарь ISO — широко используемый вариант григорианского календаря. [3]

Год ISO состоит из 52 или 53 полных недель; неделя начинается в понедельник и заканчивается в воскресенье. Первая неделя года ISO — это первая календарная неделя (по григорианскому календарю), содержащая четверг. Она называется неделей номер 1, а год ISO этого четверга совпадает с его годом по григорианскому календарю.

Например, 2004 год начинается в четверг, поэтому первая неделя года ISO 2004 начинается в понедельник, 29 декабря 2003 года, и заканчивается в воскресенье, 4 января 2004 года:

>>> from datetime import date
>>> date(2003, 12, 29).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=1)
>>> date(2004, 1, 4).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=7)

Изменено в версии 3.9: Результат изменён с кортежа на именованный кортеж.

date.isoformat()

Возвращает строку, представляющую дату в формате ISO 8601, YYYY-MM-DD:

>>> from datetime import date
>>> date(2002, 12, 4).isoformat()
'2002-12-04'

date.__str__()

Для даты d, str(d) эквивалентно d.isoformat().

date.ctime()

Возвращает строку, представляющую дату:

>>> from datetime import date
>>> date(2002, 12, 4).ctime()
'Wed Dec  4 00:00:00 2002'

d.ctime() эквивалентно:

time.ctime(time.mktime(d.timetuple()))

на платформах, где нативная функция ctime() языка C (вызываемая time.ctime(), но не вызываемая date.ctime()) соответствует стандарту C.

date.strftime(format)

Возвращает строку, представляющую дату; формат задаётся явно переданной строкой формата. Для кодов формата, соответствующих часам, минутам или секундам, используются значения 0. См. также разделы Поведение strftime() и strptime() и date.isoformat().

date.__format__(format)

То же, что и date.strftime(). Это позволяет задавать строку формата для объекта date в форматированных строковых литералах и при использовании str.format(). См. также разделы Поведение strftime() и strptime() и date.isoformat().

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2007, 12, 5)
>>> today == date.fromtimestamp(time.time())
True
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
...     my_birthday = my_birthday.replace(year=today.year + 1)
...
>>> my_birthday
datetime.date(2008, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
202

>>> from datetime import date
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
>>> d
datetime.date(2002, 3, 11)

>>> # Methods related to formatting string output
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> d.ctime()
'Mon Mar 11 00:00:00 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

>>> # Methods for to extracting 'components' under different calendars
>>> t = d.timetuple()
>>> for i in t:
...     print(i)
2002                # year
3                   # month
11                  # day
0
0
0
0                   # weekday (0 = Monday)
70                  # 70th day in the year
-1
>>> ic = d.isocalendar()
>>> for i in ic:
...     print(i)
2002                # ISO year
11                  # ISO week number
1                   # ISO day number ( 1 = Monday )

>>> # A date object is immutable; all operations produce a new object
>>> d.replace(year=2005)
datetime.date(2005, 3, 11)

Объекты datetime

Объект datetime содержит всю информацию из объекта date и объекта time.

Как и объект date, datetime предполагает, что текущий григорианский календарь продолжен в обоих направлениях; как и объект time, datetime предполагает, что в каждом дне ровно 3600*24 секунд.

Конструктор:

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

Аргументы year, month и day обязательны. tzinfo может быть None или экземпляром подкласса tzinfo. Остальные аргументы должны быть целыми числами в следующих диапазонах:

• MINYEAR <= year <= MAXYEAR,
• 1 <= month <= 12,
• 1 <= day <= number of days in the given month and year,
• 0 <= hour < 24,
• 0 <= minute < 60,
• 0 <= second < 60,
• 0 <= microsecond < 1000000,
• fold in [0, 1].

Если задан аргумент за пределами этих диапазонов, вызывается ValueError.

Изменено в версии 3.6: Добавлен параметр fold.

Другие конструкторы, все являются методами класса:

classmethod datetime.today()

Возвращает текущие локальные дату и время, причём tzinfo равен None.

Эквивалентно:

datetime.fromtimestamp(time.time())

См. также now(), fromtimestamp().

Этот метод функционально эквивалентен now(), но без параметра tz.

classmethod datetime.now(tz=None)

Возвращает текущие локальные дату и время.

Если необязательный аргумент tz равен None или не указан, метод работает как today(), но, если возможно, обеспечивает большую точность, чем при получении значения через временную метку time.time() (например, это может быть возможно на платформах, предоставляющих функцию C gettimeofday()).

Если tz не равен None, он должен быть экземпляром подкласса tzinfo, а текущие дата и время преобразуются в часовой пояс tz.

Эта функция предпочтительнее, чем today() и utcnow().

Примечание

При последовательных вызовах datetime.now() может возвращаться один и тот же момент времени — это зависит от точности системных часов.

classmethod datetime.utcnow()

Возвращает текущие дату и время UTC, причём tzinfo равен None.

Этот метод похож на now(), но возвращает текущие дату и время UTC в виде наивного объекта datetime. Осведомлённый объект datetime для текущего времени UTC можно получить, вызвав datetime.now(timezone.utc). См. также now().

Предупреждение

Поскольку многие методы datetime интерпретируют наивные объекты datetime как локальное время, для представления времени UTC рекомендуется использовать осведомлённые объекты datetime. Поэтому рекомендуемый способ создания объекта, представляющего текущее время UTC, — вызов datetime.now(timezone.utc).

Устарело начиная с версии 3.12: Вместо этого используйте datetime.now() с UTC.

classmethod datetime.fromtimestamp(timestamp, tz=None)

Возвращает локальные дату и время, соответствующие временной метке POSIX, например возвращаемой функцией time.time(). Если необязательный аргумент tz равен None или не указан, временная метка преобразуется в локальные дату и время платформы, а возвращённый объект datetime является наивным.

Если tz не равен None, он должен быть экземпляром подкласса tzinfo, а временная метка преобразуется в часовой пояс tz.

fromtimestamp() может вызвать OverflowError, если временная метка находится за пределами диапазона значений, поддерживаемого функциями C платформы localtime() или gmtime(), и OSError при сбое localtime() или gmtime(). Обычно диапазон ограничен годами с 1970 по 2038. Обратите внимание, что в системах, отличных от POSIX, которые учитывают високосные секунды при определении временной метки, функция fromtimestamp() игнорирует високосные секунды, поэтому две временные метки, отличающиеся на секунду, могут возвращать одинаковые объекты datetime. Этот метод предпочтительнее, чем utcfromtimestamp().

Изменено в версии 3.3: Если временная метка находится за пределами диапазона значений, поддерживаемого функциями C платформы localtime() или gmtime(), вызывается OverflowError вместо ValueError. При сбое localtime() или gmtime() вызывается OSError вместо ValueError.

Изменено в версии 3.6: fromtimestamp() может возвращать экземпляры с атрибутом fold, установленным в 1.

classmethod datetime.utcfromtimestamp(timestamp)

Возвращает объект datetime для времени UTC, соответствующего временной метке POSIX, причём tzinfo равен None. (Результирующий объект является наивным.)

Метод может вызвать OverflowError, если временная метка находится за пределами диапазона значений, поддерживаемого функцией C платформы gmtime(), и OSError при сбое gmtime(). Обычно диапазон ограничен годами с 1970 по 2038.

Чтобы получить осведомлённый объект datetime, вызовите fromtimestamp():

datetime.fromtimestamp(timestamp, timezone.utc)

На платформах, совместимых с POSIX, это эквивалентно следующему выражению:

datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

за исключением того, что последняя формула всегда поддерживает полный диапазон лет: от MINYEAR до MAXYEAR включительно.

Предупреждение

Поскольку многие методы datetime интерпретируют наивные объекты datetime как локальное время, для представления времени UTC рекомендуется использовать осведомлённые объекты datetime. Поэтому рекомендуемый способ создания объекта, представляющего заданную временную метку UTC, — вызов datetime.fromtimestamp(timestamp, tz=timezone.utc).

Изменено в версии 3.3: Если временная метка находится за пределами диапазона значений, поддерживаемого функцией C платформы gmtime(), вызывается OverflowError вместо ValueError. При сбое gmtime() вызывается OSError вместо ValueError.

Устарело начиная с версии 3.12: Вместо этого используйте datetime.fromtimestamp() с UTC.

classmethod datetime.fromordinal(ordinal)

Возвращает объект datetime, соответствующий порядковому номеру дня в пролептическом григорианском календаре, где 1 января года 1 имеет номер 1. Вызывается ValueError, если 1 <= ordinal <= datetime.max.toordinal(). Час, минута, секунда и микросекунда результирующего объекта равны 0, а tzinfo равен None.

classmethod datetime.combine(date, time, tzinfo=time.tzinfo)

Возвращает новый объект datetime, компоненты даты которого совпадают с компонентами заданного объекта date, а компоненты времени — с компонентами заданного объекта time. Если указан аргумент tzinfo, его значение используется для установки атрибута tzinfo результата; в противном случае используется атрибут tzinfo аргумента time. Если аргумент date является объектом datetime, его компоненты времени и атрибуты tzinfo игнорируются.

Для любого объекта datetime d, d == datetime.combine(d.date(), d.time(), d.tzinfo).

Изменено в версии 3.6: Добавлен аргумент tzinfo.

classmethod datetime.fromisoformat(date_string)

Возвращает объект datetime, соответствующий строке date_string в любом допустимом формате ISO 8601, за следующими исключениями:

1. Смещения часовых поясов могут содержать дробные секунды.
2. Разделитель T может быть заменён любым одиночным символом Юникода.
3. Дробные часы и минуты не поддерживаются.
4. Даты с пониженной точностью в настоящее время не поддерживаются (YYYY-MM, YYYY).
5. Расширенные представления дат в настоящее время не поддерживаются (±YYYYYY-MM-DD).
6. Порядковые даты в настоящее время не поддерживаются (YYYY-OOO).

Примеры:

>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>> datetime.fromisoformat('20111104')
datetime.datetime(2011, 11, 4, 0, 0)
>>> datetime.fromisoformat('2011-11-04T00:05:23')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> datetime.fromisoformat('2011-11-04T00:05:23Z')
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
>>> datetime.fromisoformat('20111104T000523')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> datetime.fromisoformat('2011-W01-2T00:05:23.283')
datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
>>> datetime.fromisoformat('2011-11-04T00:05:23+04:00')
datetime.datetime(2011, 11, 4, 0, 5, 23,
    tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

Добавлено в версии 3.7.

Изменено в версии 3.11: Ранее этот метод поддерживал только форматы, которые могли быть выведены методами date.isoformat() или datetime.isoformat().

classmethod datetime.fromisocalendar(year, week, day)

Возвращает объект datetime, соответствующий дате ISO-календаря, заданной годом, неделей и днём. Компоненты datetime, не относящиеся к дате, получают стандартные значения по умолчанию. Это обратная функция к datetime.isocalendar().

Добавлено в версии 3.8.

classmethod datetime.strptime(date_string, format)

Возвращает объект datetime, соответствующий строке date_string, разобранной согласно формату format.

Если format не содержит микросекунд или информации о часовом поясе, это эквивалентно:

datetime(*(time.strptime(date_string, format)[0:6]))

Вызывается ValueError, если строку date_string и формат не удаётся разобрать с помощью time.strptime() или если функция возвращает значение, не являющееся кортежем времени. См. также разделы Поведение strftime() и strptime() и datetime.fromisoformat().

Атрибуты класса:

datetime.min

Самый ранний представимый объект datetime, datetime(MINYEAR, 1, 1, tzinfo=None).

datetime.max

Самый поздний представимый объект datetime, datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None).

datetime.resolution

Наименьшая возможная разница между неравными объектами datetime, timedelta(microseconds=1).

Атрибуты экземпляра (только для чтения):

datetime.year

От MINYEAR до MAXYEAR включительно.

datetime.month

От 1 до 12 включительно.

datetime.day

От 1 до количества дней в заданном месяце заданного года.

datetime.hour

В диапазоне range(24).

datetime.minute

В диапазоне range(60).

datetime.second

В диапазоне range(60).

datetime.microsecond

В диапазоне range(1000000).

datetime.tzinfo

Объект, переданный в качестве аргумента tzinfo конструктору datetime, или None, если аргумент не передавался.

datetime.fold

В диапазоне [0, 1]. Используется для устранения неоднозначности местного времени в течение повторяющегося интервала. (Повторяющийся интервал возникает, когда в конце периода летнего времени часы переводят назад или когда смещение UTC для текущего часового пояса уменьшается по политическим причинам.) Значения 0 и 1 соответствуют, соответственно, более раннему и более позднему из двух моментов с одинаковым представлением местного времени.

Добавлено в версии 3.6.

Поддерживаемые операции:

1. datetime2 — это интервал времени timedelta, вычитаемый из datetime1; время продвигается вперёд, если timedelta.days > 0, или назад, если timedelta.days < 0. Результат имеет тот же атрибут tzinfo, что и исходный объект datetime, и datetime2 - datetime1 == timedelta после операции. Вызывается OverflowError, если datetime2.year окажется меньше MINYEAR или больше MAXYEAR. Обратите внимание, что корректировка часового пояса не выполняется, даже если исходный объект является осведомлённым.
2. Вычисляет datetime2 так, что datetime2 + timedelta == datetime1. Как и при сложении, результат имеет тот же атрибут tzinfo, что и исходный объект datetime; корректировка часового пояса не выполняется, даже если исходный объект является осведомлённым.

3. Вычитание объекта datetime из объекта datetime определено только в том случае, если оба операнда наивные или оба осведомлённые. Если один операнд осведомлённый, а другой наивный, вызывается TypeError.

   Если оба операнда наивные или оба осведомлённые и имеют одинаковый атрибут tzinfo, атрибуты tzinfo игнорируются, а результатом является объект timedelta t так, что datetime2 + t == datetime1. В этом случае корректировка часового пояса не выполняется.

   Если оба операнда осведомлённые и имеют разные атрибуты tzinfo, a-b действует так, как если бы a и b сначала были преобразованы в наивные объекты datetime UTC. Результат — (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset()), за исключением того, что реализация никогда не вызывает переполнение.

4. Объекты datetime равны, если они представляют одну и ту же дату и время с учётом часового пояса.

   Наивные и осведомлённые объекты datetime никогда не равны. Объекты datetime никогда не равны объектам date, которые не являются также экземплярами datetime, даже если они представляют одну и ту же дату.

   Если оба сравниваемых объекта осведомлённые и имеют одинаковый атрибут tzinfo, атрибуты tzinfo и fold игнорируются, а базовые значения datetime сравниваются. Если оба сравниваемых объекта осведомлённые и имеют разные атрибуты tzinfo, сравнение выполняется так, как если бы сравниваемые значения сначала были преобразованы в datetime UTC, за исключением того, что реализация никогда не вызывает переполнение. Экземпляры datetime в повторяющемся интервале никогда не равны экземплярам datetime в другом часовом поясе.

5. datetime1 считается меньше datetime2, если datetime1 предшествует datetime2 во времени с учётом часового пояса.

   Сравнение по порядку наивных и осведомлённых объектов datetime, а также объекта datetime и объекта date, который не является экземпляром datetime, вызывает TypeError.

   Если оба сравниваемых объекта осведомлённые и имеют одинаковый атрибут tzinfo, атрибуты tzinfo и fold игнорируются, а базовые значения datetime сравниваются. Если оба сравниваемых объекта осведомлённые и имеют разные атрибуты tzinfo, сравнение выполняется так, как если бы сравниваемые значения сначала были преобразованы в datetime UTC, за исключением того, что реализация никогда не вызывает переполнение.

Методы экземпляра:

datetime.date()

Возвращает объект date с теми же годом, месяцем и днём.

datetime.time()

Возвращает объект time с теми же часом, минутой, секундой, микросекундой и значением fold. tzinfo равен None. См. также метод timetz().

Изменено в версии 3.6: Значение fold копируется в возвращаемый объект time.

datetime.timetz()

Возвращает объект time с теми же атрибутами часа, минуты, секунды, микросекунды, fold и tzinfo. См. также метод time().

Изменено в версии 3.6: Значение fold копируется в возвращаемый объект time.

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

Возвращает объект datetime с теми же атрибутами, кроме атрибутов, для которых заданы новые значения в указанных именованных аргументах. Обратите внимание: можно указать tzinfo=None, чтобы создать наивный объект datetime из осведомлённого без преобразования данных даты и времени.

Изменено в версии 3.6: Добавлен параметр fold.

datetime.astimezone(tz=None)

Возвращает объект datetime с новым атрибутом tzinfo tz, корректируя данные даты и времени так, чтобы результат представлял то же время UTC, что и self, но в местном времени часового пояса tz.

Если указан, tz должен быть экземпляром подкласса tzinfo, а его методы utcoffset() и dst() не должны возвращать None. Если self является объектом без информации о часовом поясе, считается, что он представляет время в системном часовом поясе.

Если вызван без аргументов (или с tz=None), целевым часовым поясом считается местный часовой пояс системы. Атрибут .tzinfo преобразованного экземпляра datetime будет установлен в экземпляр timezone с названием и смещением часового пояса, полученными от ОС.

Если self.tzinfo — это tz, self.astimezone(tz) равен self: данные даты и времени не корректируются. В противном случае результат представляет местное время в часовом поясе tz, соответствующее тому же времени UTC, что и self: после astz = dt.astimezone(tz), astz - astz.utcoffset() будет содержать те же данные даты и времени, что и dt - dt.utcoffset().

Если вам нужно лишь привязать объект timezone tz к объекту datetime dt, не корректируя данные даты и времени, используйте dt.replace(tzinfo=tz). Если вам нужно лишь удалить объект timezone из объекта datetime dt с информацией о часовом поясе без преобразования данных даты и времени, используйте dt.replace(tzinfo=None).

Обратите внимание, что метод tzinfo.fromutc() по умолчанию можно переопределить в подклассе tzinfo, чтобы повлиять на результат, возвращаемый методом astimezone(). Если не учитывать случаи ошибок, astimezone() работает следующим образом:

def astimezone(self, tz):
    if self.tzinfo is tz:
        return self
    # Convert self to UTC, and attach the new timezone object.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # Convert from UTC to tz's local time.
    return tz.fromutc(utc)

Изменено в версии 3.3: Теперь аргумент tz можно опустить.

Изменено в версии 3.6: Теперь метод astimezone() можно вызывать для экземпляров без информации о часовом поясе, которые считаются представляющими местное системное время.

datetime.utcoffset()

Если tzinfo равен None, возвращает None, в противном случае возвращает self.tzinfo.utcoffset(self) и вызывает исключение, если последний не возвращает None или объект timedelta с модулем меньше одного дня.

Изменено в версии 3.7: Смещение UTC больше не ограничено целым числом минут.

datetime.dst()

Если tzinfo равен None, возвращает None, в противном случае возвращает self.tzinfo.dst(self) и вызывает исключение, если последний не возвращает None или объект timedelta с модулем меньше одного дня.

Изменено в версии 3.7: Смещение летнего времени больше не ограничено целым числом минут.

datetime.tzname()

Если tzinfo равен None, возвращает None, в противном случае возвращает self.tzinfo.tzname(self) и вызывает исключение, если последний не возвращает None или строковый объект,

datetime.timetuple()

Возвращает time.struct_time, например такой, какой возвращает time.localtime().

d.timetuple() эквивалентен:

time.struct_time((d.year, d.month, d.day,
                  d.hour, d.minute, d.second,
                  d.weekday(), yday, dst))

где yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 — номер дня в текущем году, начиная с 1 для 1 января. Флаг tm_isdst результата устанавливается в соответствии с методом dst(): если tzinfo равен None или dst() возвращает None, значение tm_isdst устанавливается в -1; если же dst() возвращает ненулевое значение, tm_isdst устанавливается в 1; в противном случае tm_isdst устанавливается в 0.

datetime.utctimetuple()

Если экземпляр datetime d не содержит информации о часовом поясе, этот метод совпадает с d.timetuple(), за исключением того, что tm_isdst принудительно устанавливается в 0 независимо от того, что возвращает d.dst(). Для времени UTC переход на летнее время никогда не действует.

Если d содержит информацию о часовом поясе, d нормализуется к времени UTC вычитанием d.utcoffset(), после чего возвращается time.struct_time для нормализованного времени. Значение tm_isdst принудительно устанавливается в 0. Обратите внимание: может быть вызвано исключение OverflowError, если d.year было равно MINYEAR или MAXYEAR и корректировка времени UTC выходит за границы года.

Предупреждение

Поскольку многие методы datetime трактуют объекты datetime без информации о часовом поясе как местное время, для представления времени UTC предпочтительно использовать объекты datetime с информацией о часовом поясе; поэтому использование datetime.utctimetuple() может привести к неверным результатам. Если у вас есть объект datetime без информации о часовом поясе, представляющий время UTC, используйте datetime.replace(tzinfo=timezone.utc), чтобы добавить информацию о часовом поясе; после этого можно использовать datetime.timetuple().

datetime.toordinal()

Возвращает порядковый номер даты в пролептическом григорианском календаре. То же, что и self.date().toordinal().

datetime.timestamp()

Возвращает метку времени POSIX, соответствующую экземпляру datetime. Возвращаемое значение — float, аналогичное значению, возвращаемому time.time().

Предполагается, что экземпляры datetime без информации о часовом поясе представляют местное время; для преобразования этот метод использует функцию C mktime() платформы. Поскольку на многих платформах диапазон поддерживаемых значений datetime шире, чем у mktime(), этот метод может вызвать OverflowError или OSError для дат в далёком прошлом или далёком будущем.

Для экземпляров datetime с информацией о часовом поясе возвращаемое значение вычисляется следующим образом:

(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

Добавлено в версии 3.3.

Изменено в версии 3.6: Метод timestamp() использует атрибут fold, чтобы различать моменты времени в повторяющемся интервале.

Примечание

Не существует метода для непосредственного получения метки времени POSIX из экземпляра datetime без информации о часовом поясе, представляющего время UTC. Если приложение использует такое соглашение, а системный часовой пояс не установлен в UTC, получить метку времени POSIX можно, указав tzinfo=timezone.utc:

timestamp = dt.replace(tzinfo=timezone.utc).timestamp()

или вычислив метку времени напрямую:

timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)

datetime.weekday()

Возвращает день недели в виде целого числа: понедельник — 0, воскресенье — 6. То же, что и self.date().weekday(). См. также isoweekday().

datetime.isoweekday()

Возвращает день недели в виде целого числа: понедельник — 1, воскресенье — 7. То же, что и self.date().isoweekday(). См. также weekday(), isocalendar().

datetime.isocalendar()

Возвращает именованный кортеж из трёх компонентов: year, week и weekday. То же, что и self.date().isocalendar().

datetime.isoformat(sep='T', timespec='auto')

Возвращает строку, представляющую дату и время в формате ISO 8601:

• YYYY-MM-DDTHH:MM:SS.ffffff, если microsecond не равно 0
• YYYY-MM-DDTHH:MM:SS, если microsecond равно 0

Если utcoffset() не возвращает None, в конец добавляется строка со смещением UTC:

• YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], если microsecond не равно 0
• YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]], если microsecond равно 0

Примеры:

>>> from datetime import datetime, timezone
>>> datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()
'2019-05-18T15:17:08.132263'
>>> datetime(2019, 5, 18, 15, 17, tzinfo=timezone.utc).isoformat()
'2019-05-18T15:17:00+00:00'

Необязательный аргумент sep (по умолчанию 'T') — это разделитель из одного символа, помещаемый между частями результата, содержащими дату и время. Например:

>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     """A time zone with an arbitrary, constant -06:39 offset."""
...     def utcoffset(self, dt):
...         return timedelta(hours=-6, minutes=-39)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
>>> datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
'2009-11-27T00:00:00.000100-06:39'

Необязательный аргумент timespec задаёт количество дополнительных компонентов времени, которые нужно включить (по умолчанию 'auto'). Он может принимать одно из следующих значений:

• 'auto': то же, что и 'seconds', если microsecond равно 0, иначе то же, что и 'microseconds'.
• 'hours': включает hour в двухзначном формате HH.
• 'minutes': включает hour и minute в формате HH:MM.
• 'seconds': включает hour, minute и second в формате HH:MM:SS.
• 'milliseconds': включает время целиком, но усекает дробную часть секунды до миллисекунд. Формат HH:MM:SS.sss.
• 'microseconds': включает время целиком в формате HH:MM:SS.ffffff.

Примечание

Исключённые компоненты времени усекаются, а не округляются.

При недопустимом аргументе timespec будет вызвано исключение ValueError:

>>> from datetime import datetime
>>> datetime.now().isoformat(timespec='minutes')
'2002-12-25T00:00'
>>> dt = datetime(2015, 1, 1, 12, 30, 59, 0)
>>> dt.isoformat(timespec='microseconds')
'2015-01-01T12:30:59.000000'

Изменено в версии 3.6: Добавлен параметр timespec.

datetime.__str__()

Для экземпляра datetime d выражение str(d) эквивалентно d.isoformat(' ').

datetime.ctime()

Возвращает строку, представляющую дату и время:

>>> from datetime import datetime
>>> datetime(2002, 12, 4, 20, 30, 40).ctime()
'Wed Dec  4 20:30:40 2002'

Выходная строка не будет содержать сведения о часовом поясе независимо от того, содержит ли входное значение информацию о часовом поясе.

d.ctime() эквивалентен:

time.ctime(time.mktime(d.timetuple()))

на платформах, где собственная функция C ctime() (которую вызывает time.ctime(), но не вызывает datetime.ctime()) соответствует стандарту C.

datetime.strftime(format)

Возвращает строку, представляющую дату и время; формат задаётся явной строкой формата. См. также разделы Поведение strftime() и strptime() и datetime.isoformat().

datetime.__format__(format)

То же, что и datetime.strftime(). Это позволяет задавать строку формата для объекта datetime в форматированных строковых литералах и при использовании str.format(). См. также разделы Поведение strftime() и strptime() и datetime.isoformat().

>>> from datetime import datetime, date, time, timezone

>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)

>>> # Using datetime.now()
>>> datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.now(timezone.utc)
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)

>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)

>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:
...     print(it)
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None

>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:
...     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday

>>> # Formatting a datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'

from datetime import timedelta, datetime, tzinfo, timezone

class KabulTz(tzinfo):
    # Kabul used +4 until 1945, when they moved to +4:30
    UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)

    def utcoffset(self, dt):
        if dt.year < 1945:
            return timedelta(hours=4)
        elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
            # An ambiguous ("imaginary") half-hour range representing
            # a 'fold' in time due to the shift from +4 to +4:30.
            # If dt falls in the imaginary range, use fold to decide how
            # to resolve. See PEP495.
            return timedelta(hours=4, minutes=(30 if dt.fold else 0))
        else:
            return timedelta(hours=4, minutes=30)

    def fromutc(self, dt):
        # Follow same validations as in datetime.tzinfo
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() requires a datetime argument")
        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        # A custom implementation is required for fromutc as
        # the input to this function is a datetime with utc values
        # but with a tzinfo set to self.
        # See datetime.astimezone or fromtimestamp.
        if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
            return dt + timedelta(hours=4, minutes=30)
        else:
            return dt + timedelta(hours=4)

    def dst(self, dt):
        # Kabul does not observe daylight saving time.
        return timedelta(0)

    def tzname(self, dt):
        if dt >= self.UTC_MOVE_DATE:
            return "+04:30"
        return "+04"

>>> tz1 = KabulTz()

>>> # Datetime before the change
>>> dt1 = datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
>>> print(dt1.utcoffset())
4:00:00

>>> # Datetime after the change
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
>>> print(dt2.utcoffset())
4:30:00

>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(timezone.utc)
>>> dt3
datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
>>> dt2
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
>>> dt2 == dt3
True

Объекты time

Объект time представляет время суток (местное), не зависящее от конкретного дня и подлежащее корректировке с помощью объекта tzinfo.

class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

Все аргументы необязательны. tzinfo может быть None или экземпляром подкласса tzinfo. Остальные аргументы должны быть целыми числами в следующих диапазонах:

• 0 <= hour < 24,
• 0 <= minute < 60,
• 0 <= second < 60,
• 0 <= microsecond < 1000000,
• fold in [0, 1].

Если передан аргумент, выходящий за эти диапазоны, вызывается ValueError. Значения по умолчанию для всех аргументов равны 0, за исключением tzinfo, значение которого по умолчанию — None.

Атрибуты класса:

time.min

Самое раннее представимое значение time, time(0, 0, 0, 0).

time.max

Самое позднее представимое значение time, time(23, 59, 59, 999999).

time.resolution

Наименьшая возможная разница между неравными объектами time, timedelta(microseconds=1), однако обратите внимание, что арифметические операции с объектами time не поддерживаются.

Атрибуты экземпляра (только для чтения):

time.hour

В range(24).

time.minute

В range(60).

time.second

В range(60).

time.microsecond

В range(1000000).

time.tzinfo

Объект, переданный в качестве аргумента tzinfo конструктору time, или None, если такой аргумент не передан.

time.fold

В [0, 1]. Используется для устранения неоднозначности локального времени в повторяющемся интервале. (Повторяющийся интервал возникает, когда часы переводят назад в конце периода летнего времени или когда смещение UTC для текущего часового пояса уменьшается по политическим причинам.) Значения 0 и 1 обозначают соответственно более ранний и более поздний из двух моментов времени с одинаковым представлением локального времени.

Добавлено в версии 3.6.

Объекты time поддерживают проверки на равенство и сравнения порядка, при которых a считается меньше b, если a предшествует b по времени.

Наивные и осведомлённые объекты time никогда не равны. Сравнение порядка между наивными и осведомлёнными объектами time вызывает TypeError.

Если оба сравниваемых объекта являются осведомлёнными и имеют одинаковый атрибут tzinfo, атрибуты tzinfo и fold игнорируются, а сравниваются базовые значения времени. Если оба сравниваемых объекта являются осведомлёнными и имеют разные атрибуты tzinfo, перед сравнением из них вычитаются смещения UTC (полученные с помощью self.utcoffset()).

В логических контекстах объект time всегда считается истинным.

Другой конструктор:

classmethod time.fromisoformat(time_string)

Возвращает объект time, соответствующий строке time_string в любом допустимом формате ISO 8601, за следующими исключениями:

1. Смещения часовых поясов могут содержать дробные секунды.
2. Начальный символ T, обычно обязательный в случаях возможной неоднозначности между датой и временем, не требуется.
3. Дробные секунды могут содержать любое количество цифр (все цифры после шестой отбрасываются).
4. Дробные часы и минуты не поддерживаются.

Примеры:

>>> from datetime import time
>>> time.fromisoformat('04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('T04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('T042301')
datetime.time(4, 23, 1)
>>> time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)
>>> time.fromisoformat('04:23:01,000384')
datetime.time(4, 23, 1, 384)
>>> time.fromisoformat('04:23:01+04:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
>>> time.fromisoformat('04:23:01Z')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)
>>> time.fromisoformat('04:23:01+00:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)

Добавлено в версии 3.7.

Изменено в версии 3.11: Ранее этот метод поддерживал только форматы, которые могли быть выведены с помощью time.isoformat().

Методы экземпляра:

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

Возвращает объект time с тем же значением, за исключением атрибутов, которым присваиваются новые значения указанными именованными аргументами. Обратите внимание: можно указать tzinfo=None, чтобы создать наивный объект time из осведомлённого объекта time без преобразования данных о времени.

Изменено в версии 3.6: Добавлен параметр fold.

time.isoformat(timespec='auto')

Возвращает строку, представляющую время в формате ISO 8601, в одном из следующих видов:

• HH:MM:SS.ffffff, если microsecond не равен 0
• HH:MM:SS, если microsecond равен 0
• HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], если utcoffset() возвращает не None
• HH:MM:SS+HH:MM[:SS[.ffffff]], если microsecond равен 0, а utcoffset() возвращает не None

Необязательный аргумент timespec задаёт количество дополнительных компонентов времени (по умолчанию используется 'auto'). Возможны следующие значения:

• 'auto': то же, что и 'seconds', если microsecond равен 0, иначе то же, что и 'microseconds'.
• 'hours': включить hour в двухзначном формате HH.
• 'minutes': включить hour и minute в формате HH:MM.
• 'seconds': включить hour, minute и second в формате HH:MM:SS.
• 'milliseconds': включить полное время, но усечь дробную часть секунд до миллисекунд. Формат HH:MM:SS.sss.
• 'microseconds': включить полное время в формате HH:MM:SS.ffffff.

Примечание

Исключённые компоненты времени усекаются, а не округляются.

Если аргумент timespec недопустим, будет вызвано исключение ValueError.

Пример:

>>> from datetime import time
>>> time(hour=12, minute=34, second=56, microsecond=123456).isoformat(timespec='minutes')
'12:34'
>>> dt = time(hour=12, minute=34, second=56, microsecond=0)
>>> dt.isoformat(timespec='microseconds')
'12:34:56.000000'
>>> dt.isoformat(timespec='auto')
'12:34:56'

Изменено в версии 3.6: Добавлен параметр timespec.

time.__str__()

Для времени t, str(t) эквивалентно t.isoformat().

time.strftime(format)

Возвращает строку, представляющую время; формат задаётся явной строкой формата. См. также разделы Поведение strftime() и strptime() и time.isoformat().

time.__format__(format)

То же, что и time.strftime(). Это позволяет задавать строку формата для объекта time в форматированных строковых литералах и при использовании str.format(). См. также разделы Поведение strftime() и strptime() и time.isoformat().

time.utcoffset()

Если tzinfo равно None, возвращает None, иначе возвращает self.tzinfo.utcoffset(None) и вызывает исключение, если последнее не возвращает None или объект timedelta с абсолютным значением меньше суток.

Изменено в версии 3.7: Смещение UTC не ограничено целым числом минут.

time.dst()

Если tzinfo равно None, возвращает None, иначе возвращает self.tzinfo.dst(None) и вызывает исключение, если последнее не возвращает None или объект timedelta с абсолютным значением меньше суток.

Изменено в версии 3.7: Смещение летнего времени не ограничено целым числом минут.

time.tzname()

Если tzinfo равно None, возвращает None, иначе возвращает self.tzinfo.tzname(None) или вызывает исключение, если последнее не возвращает None либо строковый объект.

>>> from datetime import time, tzinfo, timedelta
>>> class TZ1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self,dt):
...         return "+01:00"
...     def  __repr__(self):
...         return f"{self.__class__.__name__}()"
...
>>> t = time(12, 10, 30, tzinfo=TZ1())
>>> t
datetime.time(12, 10, 30, tzinfo=TZ1())
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'+01:00'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 +01:00'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 12:10.'

Объекты tzinfo

class datetime.tzinfo

Это абстрактный базовый класс, то есть его не следует создавать напрямую. Определите подкласс tzinfo, чтобы сохранить сведения о конкретном часовом поясе.

Экземпляр (конкретного подкласса) tzinfo можно передать конструкторам объектов datetime и time. Эти объекты рассматривают свои атрибуты как значения местного времени, а объект tzinfo предоставляет методы, возвращающие смещение местного времени относительно UTC, название часового пояса и смещение летнего времени относительно переданного им объекта даты или времени.

Необходимо создать конкретный подкласс и реализовать (как минимум) стандартные методы tzinfo, необходимые используемым вами методам datetime. Модуль datetime предоставляет класс timezone — простой конкретный подкласс tzinfo, который может представлять часовые пояса с фиксированным смещением относительно UTC, например сам UTC или североамериканские EST и EDT.

Особое требование для сериализации с помощью pickle: подкласс tzinfo должен иметь метод __init__(), который можно вызвать без аргументов; в противном случае объект можно сериализовать с помощью pickle, но, возможно, нельзя будет десериализовать. Это техническое требование, которое в будущем может быть смягчено.

Конкретному подклассу tzinfo может потребоваться реализовать следующие методы. Точный набор необходимых методов зависит от того, как используются объекты datetime с информацией о часовом поясе. Если вы сомневаетесь, просто реализуйте их все.

tzinfo.utcoffset(dt)

Возвращает смещение местного времени относительно UTC в виде объекта timedelta. Положительное значение означает, что местное время опережает UTC. Если местное время отстаёт от UTC, значение должно быть отрицательным.

Это общее смещение относительно UTC; например, если объект tzinfo представляет часовой пояс и поправку на летнее время, метод utcoffset() должен возвращать их сумму. Если смещение относительно UTC неизвестно, верните None. В противном случае возвращаемое значение должно быть объектом timedelta, строго большим -timedelta(hours=24) и строго меньшим timedelta(hours=24) (абсолютное значение смещения должно быть меньше одного дня). Большинство реализаций utcoffset(), вероятно, будут похожи на один из этих двух вариантов:

return CONSTANT                 # fixed-offset class
return CONSTANT + self.dst(dt)  # daylight-aware class

Если utcoffset() возвращает не None, метод dst() также не должен возвращать None.

Реализация utcoffset() по умолчанию вызывает исключение NotImplementedError.

Изменено в версии 3.7: Смещение UTC больше не ограничено целым числом минут.

tzinfo.dst(dt)

Возвращает поправку на летнее время (DST) в виде объекта timedelta или None, если сведения о летнем времени неизвестны.

Возвращает timedelta(0), если летнее время не действует. Если летнее время действует, возвращает смещение в виде объекта timedelta (подробности см. в описании utcoffset()). Обратите внимание: если поправка на летнее время применима, она уже учтена в смещении UTC, возвращаемом методом utcoffset(), поэтому обращаться к dst() нужно только в том случае, если сведения о летнем времени нужны отдельно. Например, datetime.timetuple() вызывает метод dst() атрибута tzinfo, чтобы определить, как следует установить флаг tm_isdst, а tzinfo.fromutc() вызывает dst(), чтобы учесть переходы на летнее время при пересечении часовых поясов.

Экземпляр tz подкласса tzinfo, моделирующего стандартное и летнее время, должен быть согласован в следующем смысле:

tz.utcoffset(dt) - tz.dst(dt)

должен возвращать один и тот же результат для каждого объекта datetime dt, для которого dt.tzinfo == tz. Для корректных подклассов tzinfo это выражение возвращает «стандартное смещение» часового пояса, которое не должно зависеть от даты или времени, а должно определяться только географическим положением. Реализация datetime.astimezone() полагается на это, но не может обнаружить нарушения; за соблюдение этого условия отвечает программист. Если подкласс tzinfo не может этого гарантировать, он может переопределить реализацию tzinfo.fromutc() по умолчанию, чтобы она корректно работала с astimezone() в любом случае.

Большинство реализаций dst(), вероятно, будут похожи на один из этих двух вариантов:

def dst(self, dt):
    # a fixed-offset class:  doesn't account for DST
    return timedelta(0)

или:

def dst(self, dt):
    # Code to set dston and dstoff to the time zone's DST
    # transition times based on the input dt.year, and expressed
    # in standard local time.

    if dston <= dt.replace(tzinfo=None) < dstoff:
        return timedelta(hours=1)
    else:
        return timedelta(0)

Реализация dst() по умолчанию вызывает исключение NotImplementedError.

Изменено в версии 3.7: Смещение летнего времени больше не ограничено целым числом минут.

tzinfo.tzname(dt)

Возвращает название часового пояса, соответствующее объекту datetime dt, в виде строки. Модуль datetime не устанавливает никаких требований к строковым названиям и не требует, чтобы они имели какое-либо конкретное значение. Например, "GMT", "UTC", "-500", "-5:00", "EDT", "US/Eastern", "America/New York" — все допустимые варианты. Если строковое название неизвестно, верните None. Это метод, а не фиксированная строка, главным образом потому, что некоторые подклассы tzinfo могут возвращать разные названия в зависимости от переданного значения dt, особенно если класс tzinfo учитывает летнее время.

Реализация tzname() по умолчанию вызывает исключение NotImplementedError.

Эти методы вызываются объектом datetime или time в ответ на вызов методов с такими же именами. Объект datetime передаёт в качестве аргумента сам себя, а объект time передаёт в качестве аргумента None. Поэтому методы подкласса tzinfo должны быть готовы принимать аргумент dt типа None или класса datetime.

При передаче None разработчик класса сам решает, какой ответ будет наиболее подходящим. Например, возвращать None уместно, если класс должен показать, что объекты времени не участвуют в протоколах tzinfo. Возможно, будет полезнее, если utcoffset(None) возвращает стандартное смещение UTC, поскольку другого способа определить стандартное смещение не предусмотрено.

Если объект datetime передан в ответ на вызов метода datetime, dt.tzinfo — это тот же объект, что и self. Методы tzinfo могут полагаться на это, если только пользовательский код не вызывает методы tzinfo напрямую. Предполагается, что методы tzinfo интерпретируют dt как местное время и не должны учитывать объекты в других часовых поясах.

Есть ещё один метод tzinfo, который подкласс может переопределить:

tzinfo.fromutc(dt)

Этот метод вызывается реализацией datetime.astimezone() по умолчанию. При таком вызове dt.tzinfo равен self, а данные даты и времени объекта dt следует интерпретировать как время UTC. Метод fromutc() предназначен для корректировки данных даты и времени и возврата эквивалентного объекта datetime в местном времени self.

Большинство подклассов tzinfo могут без проблем наследовать реализацию fromutc() по умолчанию. Она подходит для обработки часовых поясов с фиксированным смещением и часовых поясов, учитывающих стандартное и летнее время, даже если моменты перехода на летнее время различаются в разные годы. Пример часового пояса, для которого реализация fromutc() по умолчанию может работать некорректно в некоторых случаях, — это часовой пояс, где стандартное смещение относительно UTC зависит от конкретных переданных даты и времени, что может происходить по политическим причинам. Реализации astimezone() и fromutc() по умолчанию могут дать нежелательный результат, если он приходится на один из часов, охватывающих момент изменения стандартного смещения.

Если опустить обработку ошибок, реализация fromutc() по умолчанию работает примерно так:

def fromutc(self, dt):
    # raise ValueError error if dt.tzinfo is not self
    dtoff = dt.utcoffset()
    dtdst = dt.dst()
    # raise ValueError if dtoff is None or dtdst is None
    delta = dtoff - dtdst  # this is self's standard offset
    if delta:
        dt += delta   # convert to standard local time
        dtdst = dt.dst()
        # raise ValueError if dtdst is None
    if dtdst:
        return dt + dtdst
    else:
        return dt

В следующем файле tzinfo_examples.py приведены примеры классов tzinfo:

from datetime import tzinfo, timedelta, datetime

ZERO = timedelta(0)
HOUR = timedelta(hours=1)
SECOND = timedelta(seconds=1)

# A class capturing the platform's idea of local time.
# (May result in wrong values on historical times in
#  timezones where UTC offset and/or the DST rules had
#  changed in the past.)
import time as _time

STDOFFSET = timedelta(seconds = -_time.timezone)
if _time.daylight:
    DSTOFFSET = timedelta(seconds = -_time.altzone)
else:
    DSTOFFSET = STDOFFSET

DSTDIFF = DSTOFFSET - STDOFFSET

class LocalTimezone(tzinfo):

    def fromutc(self, dt):
        assert dt.tzinfo is self
        stamp = (dt - datetime(1970, 1, 1, tzinfo=self)) // SECOND
        args = _time.localtime(stamp)[:6]
        dst_diff = DSTDIFF // SECOND
        # Detect fold
        fold = (args == _time.localtime(stamp - dst_diff))
        return datetime(*args, microsecond=dt.microsecond,
                        tzinfo=self, fold=fold)

    def utcoffset(self, dt):
        if self._isdst(dt):
            return DSTOFFSET
        else:
            return STDOFFSET

    def dst(self, dt):
        if self._isdst(dt):
            return DSTDIFF
        else:
            return ZERO

    def tzname(self, dt):
        return _time.tzname[self._isdst(dt)]

    def _isdst(self, dt):
        tt = (dt.year, dt.month, dt.day,
              dt.hour, dt.minute, dt.second,
              dt.weekday(), 0, 0)
        stamp = _time.mktime(tt)
        tt = _time.localtime(stamp)
        return tt.tm_isdst > 0

Local = LocalTimezone()


# A complete implementation of current DST rules for major US time zones.

def first_sunday_on_or_after(dt):
    days_to_go = 6 - dt.weekday()
    if days_to_go:
        dt += timedelta(days_to_go)
    return dt


# US DST Rules
#
# This is a simplified (i.e., wrong for a few cases) set of rules for US
# DST start and end times. For a complete and up-to-date set of DST rules
# and timezone definitions, visit the Olson Database (or try pytz):
# http://www.twinsun.com/tz/tz-link.htm
# https://sourceforge.net/projects/pytz/ (might not be up-to-date)
#
# In the US, since 2007, DST starts at 2am (standard time) on the second
# Sunday in March, which is the first Sunday on or after Mar 8.
DSTSTART_2007 = datetime(1, 3, 8, 2)
# and ends at 2am (DST time) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 2)
# From 1987 to 2006, DST used to start at 2am (standard time) on the first
# Sunday in April and to end at 2am (DST time) on the last
# Sunday of October, which is the first Sunday on or after Oct 25.
DSTSTART_1987_2006 = datetime(1, 4, 1, 2)
DSTEND_1987_2006 = datetime(1, 10, 25, 2)
# From 1967 to 1986, DST used to start at 2am (standard time) on the last
# Sunday in April (the one on or after April 24) and to end at 2am (DST time)
# on the last Sunday of October, which is the first Sunday
# on or after Oct 25.
DSTSTART_1967_1986 = datetime(1, 4, 24, 2)
DSTEND_1967_1986 = DSTEND_1987_2006

def us_dst_range(year):
    # Find start and end times for US DST. For years before 1967, return
    # start = end for no DST.
    if 2006 < year:
        dststart, dstend = DSTSTART_2007, DSTEND_2007
    elif 1986 < year < 2007:
        dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
    elif 1966 < year < 1987:
        dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
    else:
        return (datetime(year, 1, 1), ) * 2

    start = first_sunday_on_or_after(dststart.replace(year=year))
    end = first_sunday_on_or_after(dstend.replace(year=year))
    return start, end


class USTimeZone(tzinfo):

    def __init__(self, hours, reprname, stdname, dstname):
        self.stdoffset = timedelta(hours=hours)
        self.reprname = reprname
        self.stdname = stdname
        self.dstname = dstname

    def __repr__(self):
        return self.reprname

    def tzname(self, dt):
        if self.dst(dt):
            return self.dstname
        else:
            return self.stdname

    def utcoffset(self, dt):
        return self.stdoffset + self.dst(dt)

    def dst(self, dt):
        if dt is None or dt.tzinfo is None:
            # An exception may be sensible here, in one or both cases.
            # It depends on how you want to treat them.  The default
            # fromutc() implementation (called by the default astimezone()
            # implementation) passes a datetime with dt.tzinfo is self.
            return ZERO
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        dt = dt.replace(tzinfo=None)
        if start + HOUR <= dt < end - HOUR:
            # DST is in effect.
            return HOUR
        if end - HOUR <= dt < end:
            # Fold (an ambiguous hour): use dt.fold to disambiguate.
            return ZERO if dt.fold else HOUR
        if start <= dt < start + HOUR:
            # Gap (a non-existent hour): reverse the fold rule.
            return HOUR if dt.fold else ZERO
        # DST is off.
        return ZERO

    def fromutc(self, dt):
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        start = start.replace(tzinfo=self)
        end = end.replace(tzinfo=self)
        std_time = dt + self.stdoffset
        dst_time = std_time + HOUR
        if end <= dst_time < end + HOUR:
            # Repeated hour
            return std_time.replace(fold=1)
        if std_time < start or dst_time >= end:
            # Standard time
            return std_time
        if start <= std_time < end - HOUR:
            # Daylight saving time
            return dst_time


Eastern  = USTimeZone(-5, "Eastern",  "EST", "EDT")
Central  = USTimeZone(-6, "Central",  "CST", "CDT")
Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
Pacific  = USTimeZone(-8, "Pacific",  "PST", "PDT")

Обратите внимание: в подклассе tzinfo, учитывающем стандартное и летнее время, дважды в год неизбежно возникают неоднозначности в моменты перехода на летнее время. Для наглядности рассмотрим восточное время США (UTC -0500): EDT начинается через минуту после 1:59 (EST) во второе воскресенье марта и заканчивается через минуту после 1:59 (EDT) в первое воскресенье ноября:

  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM
  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM
  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM

start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM

  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM

При начале действия летнего времени (строка «start») местные часы перескакивают с 1:59 на 3:00. Местное время вида 2:MM в этот день фактически не существует, поэтому astimezone(Eastern) не вернёт результат с hour == 2 в день перехода на летнее время. Например, при весеннем переходе 2016 года получаем:

>>> from datetime import datetime, timezone
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = datetime(2016, 3, 13, 5, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname())
...
05:00:00 UTC = 00:00:00 EST
06:00:00 UTC = 01:00:00 EST
07:00:00 UTC = 03:00:00 EDT
08:00:00 UTC = 04:00:00 EDT

При окончании действия летнего времени (строка «end») возникает потенциально более серьёзная проблема: один час нельзя однозначно обозначить местным временем — последний час летнего времени. Для восточного времени это время вида 5:MM UTC в день окончания летнего времени. Местные часы снова перескакивают с 1:59 (летнее время) назад на 1:00 (стандартное время). Местное время вида 1:MM неоднозначно. Метод astimezone() имитирует поведение местных часов, преобразуя два последовательных часа UTC в один и тот же местный час. В примере с восточным временем значения UTC вида 5:MM и 6:MM при преобразовании в восточное время оба становятся 1:MM, однако для более ранних значений атрибут fold равен 0, а для более поздних — 1. Например, при осеннем переходе 2016 года получаем:

>>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)
...
04:00:00 UTC = 00:00:00 EDT 0
05:00:00 UTC = 01:00:00 EDT 0
06:00:00 UTC = 01:00:00 EST 1
07:00:00 UTC = 02:00:00 EST 0

Обратите внимание: экземпляры datetime, различающиеся только значением атрибута fold, считаются равными при сравнении.

Приложения, в которых недопустимы неоднозначности местного времени, должны явно проверять значение атрибута fold или избегать использования гибридных подклассов tzinfo. Неоднозначностей нет при использовании timezone или любого другого подкласса tzinfo с фиксированным смещением (например, класса, представляющего только EST с фиксированным смещением -5 часов или только EDT с фиксированным смещением -4 часа).

Объекты timezone

Класс timezone является подклассом tzinfo. Каждый его экземпляр представляет часовой пояс с фиксированным смещением относительно UTC.

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

class datetime.timezone(offset, name=None)

Аргумент offset необходимо задавать объектом timedelta, представляющим разницу между местным временем и UTC. Он должен быть строго больше -timedelta(hours=24) и строго меньше timedelta(hours=24), иначе возникает исключение ValueError.

Аргумент name необязателен. Если он задан, то должен быть строкой, которая будет возвращаться методом datetime.tzname().

Добавлено в версии 3.2.

Изменено в версии 3.7: Смещение UTC больше не ограничено целым числом минут.

timezone.utcoffset(dt)

Возвращает фиксированное значение, заданное при создании экземпляра timezone.

Аргумент dt игнорируется. Возвращаемое значение — экземпляр timedelta, равный разнице между местным временем и UTC.

Изменено в версии 3.7: Смещение UTC больше не ограничено целым числом минут.

timezone.tzname(dt)

Возвращает фиксированное значение, заданное при создании экземпляра timezone.

Если при создании объекта аргумент name не указан, название, возвращаемое методом tzname(dt), формируется из значения offset следующим образом. Если offset равен timedelta(0), названием будет «UTC», в противном случае используется строка формата UTC±HH:MM, где ± — знак offset, а HH и MM — две цифры, обозначающие соответственно offset.hours и offset.minutes.

Изменено в версии 3.6: Название, создаваемое из offset=timedelta(0), теперь является обычным 'UTC', а не 'UTC+00:00'.

timezone.dst(dt)

Всегда возвращает None.

timezone.fromutc(dt)

Возвращает dt + offset. Аргумент dt должен быть объектом datetime с информацией о часовом поясе, у которого tzinfo установлен в self.

Атрибуты класса:

timezone.utc

Часовой пояс UTC, timezone(timedelta(0)).

Поведение strftime() и strptime()

Объекты date, datetime и time поддерживают метод strftime(format), создающий строку, представляющую время в соответствии с явно заданной строкой формата.

И наоборот, метод класса datetime.strptime() создает объект datetime из строки, представляющей дату и время, и соответствующей строки формата.

В таблице ниже приводится общий обзор различий между strftime() и strptime():

>>> datetime.strptime('31/01/22 23:59:59.999999',
...                   '%d/%m/%y %H:%M:%S.%f')
datetime.datetime(2022, 1, 31, 23, 59, 59, 999999)
>>> _.strftime('%a %d %b %Y, %I:%M%p')
'Mon 31 Jan 2022, 11:59PM'

datetime(*(time.strptime(date_string, format)[0:6]))