Как найти разницу между датами python

Время на прочтение
6 мин

Количество просмотров 34K

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

А именно, здесь мы коснёмся следующих вопросов:

• Как пользоваться Python-модулем datetime для работы с датой и временем.
• Что собой представляют объекты timedelta и что они могут дать программисту.
• Как вычислять продолжительность временных интервалов, выражая результат в разных единицах измерения.

Python-модуль datetime

Для работы с датой и временем в Python используется модуль datetime. Он является частью стандартной библиотеки Python. Для того чтобы применить этот модуль в своём проекте — достаточно его импортировать:

import datetime

Для вычисления продолжительности временного интервала нужно создать две различных отметки времени. Тут есть несколько вариантов:

• Два объекта date — стандартное представление даты.
• Два объекта time — стандартное представление времени.
• Два объекта datetime, комбинирующие сведения, которые обычно хранятся в объектах date и time.

Создание объектов date

Импортируем класс date из модуля datetime. Для того чтобы создать в Python объект date — можно воспользоваться обычной синтаксической конструкцией вида datetime.date(<year>,<month>,<day>). Вот пример создания объекта date с именем date1:

from datetime import date
date1 = datetime.date(2022,3,27)
print(date1)

# Вывод: 2022-03-27

Этот код можно попробовать запустить в онлайн-интерпретаторе Python на Geekflare. Ещё можно установить Python у себя.

Из предыдущего примера видно, что дата выводится в формате YYYY-MM-DD.

Обратите внимание на то, что при создании объекта date месяц надо задавать с использованием целого числа, в начале которого нет дополнительных нулей. Обычно в числовой записи месяцев соответствующие числа дополняют нулями. Здесь же, например, чтобы указать Июнь, то есть — 6 месяц — нужно воспользоваться числом 6, а не 06.

Попробуйте запустить следующий фрагмент кода. Тут месяц намеренно записан неправильно — 03 вместо 3. Из-за этого возникает ошибка SyntaxError:

date1 = datetime.date(2022,03,27)

print(date1)

# Сообщение об ошибке
File "<ipython-input-12-6eb72084e6ce>", line 1
    date1 = datetime.date(2022,03,27)
                                ^
SyntaxError: invalid token

Поговорим теперь о том, как создавать объекты time.

Создание объектов time

Для создания объектов time импортируем класс time. При создании таких объектов указывают следующие атрибуты класса: hour, minute, second и microsecond. Они, соответственно, позволяют указывать часы, минуты, секунды и микросекунды.

Правда, все эти атрибуты являются необязательными. Если какой-то из них опустить, предположим — second, то он, по умолчанию, будет установлен в 0.

В следующем примере показано создание объекта time с именем time1. Так же, как и при работе с объектами date, объекты time можно выводить в консоль:

from datetime import time
time1 = datetime.time(13,27,45,4600)
print(time1)

# Вывод: 13:27:45.004600

Создание объектов datetime

Как видите, объекты типа date не содержат сведений о времени. А в объектах time нет информации о дате.

Но на практике обычно нужны данные и о дате, и о времени. Поэтому вместо двух вышеописанных классов рекомендуется прибегнуть к классу datetime.

Обратиться к этому классу и создать соответствующий объект (dt1) можно так:

dt1 = datetime.datetime(2022,3,27,13,27,45,46000)
print(dt1)

# Вывод: 2022-03-27 13:27:45.046000

Создадим ещё один объект datetime и дадим ему имя dt2, опустив при его создании атрибут second. Это приведёт к тому, что он будет установлен в значение по умолчанию — 0.

dt2 = datetime.datetime(2022,6,30,14,28)
print(dt2)

# Вывод: 2022-06-30 14:28:00

Итак, теперь вы знаете о том, как создавать Python-объекты date, time и datetime, представляющие отметки времени. Пришло время поговорить о том, как находить длительность временных интервалов.

Применение объектов timedelta

В Python объекты timedelta представляют собой сведения о промежутках времени. Это — разница двух объектов date, time или datetime.

Если сложить или вычесть два объекта date, time или datetime, получится объект timedelta. У этого объекта имеются полезные атрибуты и методы, которые могут помочь в деле нахождения длительности временных интервалов.

Посчитаем длительность интервала, задаваемого двумя объектами типа datetime — dt1 и dt2:

dt1 = datetime.datetime(2022,3,27,13,27,45,46000) 
dt2 = datetime.datetime(2022,6,30,14,28) 
tdelta = dt2 - dt1 
print(tdelta) 
print(type(tdelta)) 

# Вывод 
95 days, 1:00:14.954000 
<class 'datetime.timedelta'>

Видно, что переменная tdelta хранит разницу между dt1 и dt2. Тут, кроме того, пользуясь встроенной Python-функцией type(), мы проверили тип tdelta. Это — timedelta.

Проведём ещё один эксперимент.

Нахождение временного промежутка между двумя датами

Рассмотрим простой, но интересный пример.

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

Для того чтобы её решить — надо сформировать первую отметку времени, указывающую на сегодняшний день, и вторую, указывающую на дату дня рождения.

Создадим пару объектов datetime:

• Первый будет хранить сегодняшнюю дату, мы назовём его today.
• Второй будет хранить дату дня рождения. Назовём его bday.

У класса datetime есть метод now(), который позволяет создавать объекты, содержащие сведения о текущем местном времени и дате. Воспользуемся этим методом для того чтобы получить сегодняшнюю дату, играющую роль точки отсчёта:

today = datetime.datetime.now()
print(today)

# Пример вывода: 2022-01-22 09:10:18.489538

Пробуя следующий код, замените значение, попадающее в bday, на дату своего дня рождения текущего года. Это позволит узнать о том, сколько времени вам ещё его ждать в этом году.

Если же ваш день рождения в этом году уже прошёл, можете записать в bday дату из следующего года.

bday = datetime.datetime(2022,8,30,11,59)
print(bday)

# Пример вывода: 2022-08-30 11:59:00

Следующий шаг нашей работы — нахождение разницы между двумя отметками времени. Её мы будем хранить в переменной time_diff. Подобные переменные, как мы уже говорили, имеют тип timedelta. Нам достаточно вычесть today из bday.

time_diff = bday - today
print(f"Your birthday is in {time_diff}")

# Вывод
Your birthday is in 220 days, 2:46:00.127416

Для того чтобы узнать о том, сколько полных дней осталось до дня рождения, можно воспользоваться атрибутом days объекта типа timedelta.

tdays = time_diff.days
print(f"Your birthday is in {tdays} days.")

# Вывод
Your birthday is in 220 days.

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

Теперь узнаем о том, сколько ждать дня рождения, выразив результат в секундах.

Для этого можно воспользоваться методом total_seconds() объекта типа timedelta. В следующем примере это — всё тот же объект time_diff.

tsecs = time_diff.total_seconds()
print(f"Your birthday is {tsecs} seconds away.")

# Вывод
Your birthday is 19017960.127416 seconds away.

Да, дня рождения придётся подождать!

Теперь вы знаете о том, как вычислять промежутки времени и выражать их в секундах.

Давайте вспомним то, что мы знаем о времени, и поговорим об измерении времени в днях, часах, минутах и секундах. В сутках 24 часа, в часе 60 минут, а 60 секунд — это минута.

Часы, минуты и секунды

Для перехода от секунд к минутам, дням или часам, можно воспользоваться следующей таблицей, деля значение в секундах на соответствующий коэффициент преобразования.

Воспользуемся этими знаниями.

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

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

Разделим то, что хранится в переменной tsecs, на 60, и сохраним то, что получится, в переменной tmins:

tmins = tsecs/60
print(f"Your birthday is {tmins} minutes away.")

# Вывод
Your birthday is 316966.0021236 minutes away.

Выражение длительности временных промежутков в часах

Теперь посчитаем длительность временного промежутка, выраженную в часах. Учитывая то, что у нас уже есть значение, выраженное в минутах, для достижения этой цели его можно просто поделить на 60. Или можно поделить значение, выраженное в секундах, на 3600 (60*60).

thrs = tsecs/(60*60)
print(f"Your birthday is {thrs} hours away.")

# Вывод
Your birthday is 5282.76670206 hours away.

Теперь вы знаете о том, как представлять разные промежутки времени в нужном вам виде.

Итоги

Освоив это руководство, вы узнали следующее:

• Как создавать объекты, содержащие сведения о дате и времени, пользуясь модулем datetime, и как работать с такими объектами.
• Как пользоваться объектами типа timedelta для нахождения длительности временных промежутков или разницы между двумя объектами, содержащими сведения о дате или времени.
• Как выражать длительность временных промежутков в секундах, минутах и часах.

Надеюсь, вам пригодится то, о чём вы узнали. Теперь эти знания вполне можно применить на практике.

Какие задачи вы решаете с помощью Python?

Using datetime example

>>> from datetime import datetime
>>> then = datetime(2012, 3, 5, 23, 8, 15)        # Random date in the past
>>> now  = datetime.now()                         # Now
>>> duration = now - then                         # For build-in functions
>>> duration_in_s = duration.total_seconds()      # Total number of seconds between dates

Duration in years

>>> years = divmod(duration_in_s, 31536000)[0]    # Seconds in a year=365*24*60*60 = 31536000.

Duration in days

>>> days  = duration.days                         # Build-in datetime function
>>> days  = divmod(duration_in_s, 86400)[0]       # Seconds in a day = 86400

Duration in hours

>>> hours = divmod(duration_in_s, 3600)[0]        # Seconds in an hour = 3600

Duration in minutes

>>> minutes = divmod(duration_in_s, 60)[0]        # Seconds in a minute = 60

Duration in seconds

[!] See warning about using duration in seconds in the bottom of this post

>>> seconds = duration.seconds                    # Build-in datetime function
>>> seconds = duration_in_s

Duration in microseconds

[!] See warning about using duration in microseconds in the bottom of this post

>>> microseconds = duration.microseconds          # Build-in datetime function

Total duration between the two dates

>>> days    = divmod(duration_in_s, 86400)        # Get days (without [0]!)
>>> hours   = divmod(days[1], 3600)               # Use remainder of days to calc hours
>>> minutes = divmod(hours[1], 60)                # Use remainder of hours to calc minutes
>>> seconds = divmod(minutes[1], 1)               # Use remainder of minutes to calc seconds
>>> print("Time between dates: %d days, %d hours, %d minutes and %d seconds" % (days[0], hours[0], minutes[0], seconds[0]))

or simply:

>>> print(now - then)

Edit 2019
Since this answer has gained traction, I’ll add a function, which might simplify the usage for some

from datetime import datetime

def getDuration(then, now = datetime.now(), interval = "default"):

    # Returns a duration as specified by variable interval
    # Functions, except totalDuration, returns [quotient, remainder]

    duration = now - then # For build-in functions
    duration_in_s = duration.total_seconds() 
    
    def years():
      return divmod(duration_in_s, 31536000) # Seconds in a year=31536000.

    def days(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 86400) # Seconds in a day = 86400

    def hours(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 3600) # Seconds in an hour = 3600

    def minutes(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 60) # Seconds in a minute = 60

    def seconds(seconds = None):
      if seconds != None:
        return divmod(seconds, 1)   
      return duration_in_s

    def totalDuration():
        y = years()
        d = days(y[1]) # Use remainder to calculate next variable
        h = hours(d[1])
        m = minutes(h[1])
        s = seconds(m[1])

        return "Time between dates: {} years, {} days, {} hours, {} minutes and {} seconds".format(int(y[0]), int(d[0]), int(h[0]), int(m[0]), int(s[0]))

    return {
        'years': int(years()[0]),
        'days': int(days()[0]),
        'hours': int(hours()[0]),
        'minutes': int(minutes()[0]),
        'seconds': int(seconds()),
        'default': totalDuration()
    }[interval]

# Example usage
then = datetime(2012, 3, 5, 23, 8, 15)
now = datetime.now()

print(getDuration(then)) # E.g. Time between dates: 7 years, 208 days, 21 hours, 19 minutes and 15 seconds
print(getDuration(then, now, 'years'))      # Prints duration in years
print(getDuration(then, now, 'days'))       #                    days
print(getDuration(then, now, 'hours'))      #                    hours
print(getDuration(then, now, 'minutes'))    #                    minutes
print(getDuration(then, now, 'seconds'))    #                    seconds

Warning: Caveat about built-in .seconds and .microseconds
datetime.seconds and datetime.microseconds are capped to [0,86400) and [0,10^6) respectively.

They should be used carefully if timedelta is bigger than the max returned value.

Examples:

end is 1h and 200μs after start:

>>> start = datetime(2020,12,31,22,0,0,500)
>>> end = datetime(2020,12,31,23,0,0,700)
>>> delta = end - start
>>> delta.microseconds
RESULT: 200
EXPECTED: 3600000200

end is 1d and 1h after start:

>>> start = datetime(2020,12,30,22,0,0)
>>> end = datetime(2020,12,31,23,0,0)
>>> delta = end - start
>>> delta.seconds
RESULT: 3600
EXPECTED: 90000

Datetime — важный элемент любой программы, написанной на Python. Этот модуль позволяет управлять датами и временем, представляя их в таком виде, в котором пользователи смогут их понимать.

datetime включает различные компоненты. Так, он состоит из объектов следующих типов:

• date — хранит дату
• time — хранит время
• datetime — хранит дату и время

Как получить текущие дату и время?

С помощью модуля Python это сделать очень просто. Сначала нужно импортировать класс datetime из модуля datetime, после чего создать объект datetime. Модуль предоставляет метод now(), который возвращает текущие дату и время с учетом локальных настроек.

import datetime


dt_now = datetime.datetime.now()

print(dt_now)

А вот результат:

2020-11-14 15:43:32.249588

Класс date можно использовать для получения или изменения объектов даты. Например, для получения текущей с учетом настроек подойдет следующее:

from datetime import date


current_date = date.today()

print(current_date)

Результат:

2020-11-14

Текущая дата — 2020-11-14 в формате год-месяц-день соответственно.

Получить текущее время

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

import datetime


current_date_time = datetime.datetime.now()

current_time = current_date_time.time()

print(current_time)

Результат:

15:51:05.627643

Компоненты datetime в Python

Модуль datetime в Python может использоваться для получения разных версий времени. Для этого нужно ознакомиться с атрибутами модуля. Используем для этого функцию dir().

import datetime


attr = dir(datetime)

print(attr)

# ['MAXYEAR', 'MINYEAR', '__doc__', '__name__', '__package__', 'date', 'datetime',

# 'datetime_CAPI', 'time', 'timedelta', 'tzinfo']

В этом руководстве речь пойдет о следующих элементах:

• date — объекты даты
• datetime — объекты даты и времени
• time — объекты времени
• timedelta — этот атрибут покрывает интервалы и используется для определения прошлых или будущих событий
• Tzinfo — этот атрибут отвечает за часовые пояса

Как создавать объекты даты и времени

Для создания объекта времени используется класс time из модуля datetime в Python. Синтаксис следующий: datetime.time(hour, minutes, seconds).

В этом примере создается объект времени представленный следующим образом (8, 48, 45).

import datetime


timeobj= datetime.time(8,48,45)

print(timeobj)

Результат такой:

08:48:45

Сначала импортируется модуль datetime. После этого создается экземпляр класса (объект time). Затем ему присваивается значение datetime.time(8, 48, 45), где параметры 8, 48 и 45 представляют собой часы, минуты и секунды соответственно.

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

datetime.datetime(year,month,day))

Такой пример:

import datetime


date_obj = datetime.datetime(2020,10,17)

print(date_obj)

Вернет вот такой результат:

2020-10-17 00:00:00

Timedelta

timedelta представляет длительность (даты или времени). Модуль datetime включает атрибут timedelta(), который используется для управления датой в Python. Объект timedelta выглядит следующим образом:

td_object =timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

td_object

datetime.timedelta(0)

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

Как вычислить разницу для двух дат

Посмотрим на несколько примеров вычисления разницы во времени. Предположим, есть два объекта datetime:

first_date = date(2020, 10, 2)
second_date = date(2020, 10, 30)

Для получения разницы нужно лишь вычесть значение одного объекта из второго:

from datetime import date


first_date = date(2020, 10, 2)

second_date = date(2020, 10, 30)

delta = second_date - first_date

print(delta)

Результат:

28 days,0:00:00

Таким образом между 2 и 30 октября 2020 года 28 дней.

Как вычислить разницу двух объектов datetime.time

С помощью timedelta нельзя выполнять манипуляции над объектами time. Например:

from datetime import datetime, timedelta


current_datetime = datetime.now()

current_time = current_datetime.time()

print("Текущее время:", current_time)

tm_after_1_hr = current_time + timedelta(hours=1)

print(tm_after_1_hr)

Такой код вернет следующую ошибку:

Traceback (most recent call last):
  File "C:UsersalexAppDataLocalProgramsPythonPython38sg_verify.py", line 6, in 
    tm_after_1_hr = current_time + timedelta(hours=1)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'

Как получать прошлые и будущие даты с помощью timedelta

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

import datetime


current_date = datetime.datetime.today()

past_date = datetime.datetime.today() – datetime.timedelta(days=n)

future_date = datetime.datetime.today() – datetime.timedelta(days=n)

Если нужно, например, получить дату за прошлые две недели, то достаточно вычесть 14 дней из текущей даты:

import datetime


past_date = datetime.datetime.today() - datetime.timedelta(days=14)

print(past_date)

Результат:

2020-10-31 16:12:09.142258

Предположим, вы задумали практиковать определенный навык в течение 21 дня. Для получения будущей даты нужно добавить 21 день к текущей дате:

import datetime


future_date = datetime.datetime.today() + datetime.timedelta(days=21)

print(future_date)

Результат:

2020-12-05 16:14:09.718325

Другие арифметические операции с timedelta

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

import datetime


now = datetime.time(9, 31, 0)

next_hour = datetime.time(10, 31, 0)

print('now < next_hour:', now < next_hour)
today = datetime.date.today()
next_week = datetime.date.today() + datetime.timedelta(days=7)
print('today > next_week:', today > next_week)

Результат:

now < next_hour: True
today > next_week: False

Часовые пояса

Пока что мы работали с datetime без учета часовых поясов и летнего времени. Но прежде чем переходить к следующим пунктам, нужно разобраться с разницей в абсолютных (naive) и относительных (aware) датах.

Абсолютные даты не содержат информацию, которая бы могла определить часовой пояс или летнее время. Однако с такими намного проще работать.

Относительные же содержат достаточно информации для определения часового пояса или отслеживания изменений из-за летнего времени.

Разница между DST, GMT и UTC

1. GMT
   Официальный часовой пояс, используемый в некоторых странах Европы и Африки. Он может быть представлен как в 24, так и в 12-часовом форматах. GMT используется для того, чтобы задавать местное время. Например, местное время для Берлина 2020–10–17 09:40:33.614581+02:00 GMT. Для Найроби же это — 2020–10–17 10:40:33.592608+03:00 GMT.
2. DST (летнее время)
   Страны, которые переходят на летнее время, делают это для того, чтобы дневное время длилось как можно дольше. Во время летнего времени они переводят стрелки своих часов на час вперед и возвращаются обратно осенью.
3. UTC (всемирное координированное время)
   Временной стандарт для часовых поясов во всем мире. Он позволяет синхронизировать время во всем мире и служит отправной точкой для остальных.

Как работать с часовыми поясами

Рассмотрим, как создать простой относительный объект datetime:

import datetime


dt_now = datetime.datetime.utcnow()

print(dt_now)

Эта программа возвращает объект с абсолютным значением datetime. Если же нужно сделать его абсолютным, то нужно явно указать часовой пояс. Как это сделать? В библиотеке datetime в Python нет модуля для работы с часовыми поясами. Для этого нужно использовать другие библиотеки. Одна из таких — pytz.

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

import pytz


pytz.all_timezones

Вот некоторые из них:

['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Nairobi']

Для получения времени в Найроби:

import pytz

import datetime


tz_nairobi = pytz.timezone("Africa/Nairobi")

dt_nairobi =datetime.datetime.now(tz_nairobi)

print(dt_nairobi)

Результат:

2020-11-14 17:27:31.141255+03:00

А вот так можно получить время Берлина:

import pytz

import datetime


tz_berlin = pytz.timezone("Europe/Berlin")

dt_berlin =datetime.datetime.now(tz_berlin)

print(dt_berlin)

Результат:

2020-11-14 15:28:20.977529+01:00

Здесь можно увидеть разницу в часовых поясах разных городов, хотя сама дата одна и та же.

Конвертация часовых поясов

При конвертации часовых поясов в первую очередь нужно помнить о том, что все атрибуты представлены в UTC. Допустим, нужно конвертировать это значение в America/New_York:

import datetime

import pytz


timezone_berlin = '2019-06-29 17:08:00'

tz_ber_obj = datetime.datetime.strptime(timezone_berlin, '%Y-%m-%d %H:%M:%S')

timezone_newyork = pytz.timezone('America/New_York')

timezone_newyork_obj = timezone_newyork.localize(tz_ber_obj)

print(timezone_newyork_obj)

print(timezone_newyork_obj.tzinfo)

Результат:

2019-06-29 17:08:00-04:00
America/New_York

Другие практические примеры

Всегда храните даты в UTC. Вот примеры:

import datetime

import pytz


time_now = datetime.datetime.now(pytz.utc)

print(time_now)

Результат для этого кода — 2020-11-14 14:38:46.462397+00:00, хотя локальное время может быть, например, таким 2020-11-14 16:38:46.462397+00:00. А уже при демонстрации даты пользователю стоит использовать метод localize с местными настройками:

import datetime

import pytz


now = datetime.datetime.today()

now_utc = pytz.utc.localize(now)

Вернет текущее локальное время — 2020-11-14 16:42:38.228528+00:00.

Как конвертировать строки в datetime

strptime() в Python — это метод из модуля datetime. Вот его синтаксис:

dateobj = datetime.strptime(date_string, format)

Аргументы формата необязательные и являются строками. Предположим, нужно извлечь текущие дату и время:

import datetime


current_dt = datetime.datetime.now()

print(current_dt)

Результат:

2020-11-14 16:50:45.049229

Результат будет в формате ISO 8601, то есть YYYY-MM-DDTHH:MM:SS.mmmmmm — формат по умолчанию, что позволяет получать строки в едином формате.

Таблица форматов:

import datetime


date_string = "11/17/20"

date_obj = datetime.datetime.strptime(date_string, '%m/%d/%y')

print(date_obj)

Результат:

2020-11-17 00:00:00

Примеры конвертации строки в объект datetime с помощью strptime

Предположим, что есть следующая строка с датой: «11/17/20 15:02:34», и ее нужно конвертировать в объект datetime.

from datetime import datetime


datetime_string = "11/17/20 15:02:34"

datetime_obj = datetime.strptime(datetime_string, '%m/%d/%y %H:%M:%S')

print(datetime_obj)

Результат:

2020-11-17 15:02:34

Даты могут быть записаны в разных форматах. Например, следующие даты отличаются лишь представлением:

• Friday, November 17, 2020;
• 11/17/20;
• 11–17–2020.

Вот как это работает:

from datetime import datetime


# создадим даты как строки

ds1 = 'Friday, November 17, 2020'

ds2 = '11/17/20'

ds3 = '11-17-2020'


# Конвертируем строки в объекты datetime и сохраним

dt1 = datetime.strptime(ds1, '%A, %B %d, %Y')

dt2 = datetime.strptime(ds2, '%m/%d/%y')

dt3 = datetime.strptime(ds3, '%m-%d-%Y')


print(dt1)

print(dt2)

print(dt3)

Результат будет одинаковым для всех форматов:

2020-11-17 00:00:00
2020-11-17 00:00:00
2020-11-17 00:00:00

Практические примеры

Если строка представлена в формате «Oct 17 2020 9:00PM», то ее можно конвертировать следующим образом:

date_string = 'Oct 17 2020 9:00PM'

date_object = datetime.strptime(date_string, '%b %d %Y %I:%M%p')

print(date_object)

Результат — 2020-10-17 21:00:00.

Функцию strptime() можно использовать для конвертации строки в объект даты:

from datetime import datetime


date_string = '10-17-2020'

date_object = datetime.strptime(date_string, '%m-%d-%Y').date()

print(type(date_object))

print(date_object)

Результат:

2020-10-17

Как конвертировать объект datetime в строку

Модуль datetime в Python содержит метод strftime(), который делает обратное (то есть, конвертирует объект datetime и time в строки). Вот его синтаксис:

datetime_string = datetime_object.strftime(format_string)
time_string = datetime_object.strftime(format_string[,time_object])

Примеры конвертации datetime в строку с помощью strftime()

Предположим, нужно конвертировать текущий объект datetime в строку. Сначала нужно получить представление объекта datetime и вызвать на нем метод strftime().

import datetime


current_date = datetime.datetime.now()

current_date_string = current_date.strftime('%m/%d/%y %H:%M:%S')

print(current_date_string)

Результат — 11/14/20 17:15:03.

Как получить строковое представление даты и времени с помощью функции format()

Пример №1. Конвертация текущей временной метки в объекте datetime в строку в формате «DD-MMM-YYYY (HH:MM:SS:MICROS)»:

import datetime


dt_obj =datetime.datetime.now()

dt_string = dt_obj.strftime("%d-%b-%Y (%H:%M:%S.%f)")

print('Текущее время : ', dt_string)

Результат:

Текущее время :  14-Nov-2020 (17:18:09.890960)

Пример №2. Конвертация текущей временной метки объекта datetime в строку в формате «HH:MM:SS.MICROS – MMM DD YYYY».

import datetime


dt_obj =datetime.datetime.now()

dt_string = dt_obj.strftime("%H:%M:%S.%f - %b %d %Y")

print('Текущее время : ', dt_string)

Результат:

Текущее время :  17:20:28.841390 - Nov 14 2020

Другие datetime-библиотеки в Python

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

Arrow

Arrow — еще один популярный модуль, который делает более простым процесс создания, управления и форматирования дат и времени. Получить его можно с помощью pip. Для установки достаточно ввести pip install arrow.

Arrow можно использовать для получения текущего времени по аналогии с модулем datetime:

import arrow


current_time = arrow.now()

print(current_time)

print(current_time.to('UTC'))

Результат:

2020-11-14T15:52:58.921198+00:00
2020-11-14T15:52:58.921198+00:00

Maya

Maya упрощает процесс парсинга строк и конвертации часовых поясов. Например:

import maya


dt = maya.parse('2019-10-17T17:45:25Z').datetime()

print(dt.date())

print(dt)

print(dt.time())

Результат:

2019-10-17
2019-10-17 17:45:25+00:00
17:45:25

Dateutil

Dateutil — это мощная библиотека, которая используется для парсинга дат и времени в разных форматах. Вот некоторые примеры.

from dateutil import parser


dt_obj = parser.parse('Thu Oct 17 17:10:28 2019')

print(dt_obj)
dt_obj1=parser.parse('Thursday, 17. October 2019 5:10PM')

print(dt_obj1)
dt_obj2=parser.parse('10/17/2019 17:10:28')

print(dt_obj2)
t_obj=parser.parse('10/17/2019')

print(t_obj)

Результат:

2019-10-17 17:10:28
2019-10-17 17:10:00
2019-10-17 17:10:28
2010-10-17 00:00:00

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

Важные нюансы

Вот о чем важно помнить при работе с datetime в Python:

• Рекомендуется всегда работать с UTC. Это позволяет не думать о часовых поясах, что часто приводит к ошибкам из-за разницы во времени в разных регионах.
• Дату и время стоит конвертировать в локальную только при выводе пользователю.

Выводы

Есть масса сценариев работы с датой и временем в реальных приложениях. Например:

• Запланировать работу скрипта на определенное время.
• Отфильтровать даты.
• Извлечь дату из определенных API каждый день, в определенное время.
• Приложения для отслеживания событий, записей, бронирования и так далее.