Модуль datetime для работы с датой и временем

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

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

• date – дата
• time – время
• datetime – дата и время
• timedelta – временной промежуток

Для использования этих классов их следует импортировать из модуля datetime:

from datetime import date, time, datetime, timedelta

Класс date

Класс date используется для представления даты без учета времени.

Объект этого класса создаётся с помощью конструктора date(), который принимает обязательные параметры year (год), month (месяц) и day (день):

date(year, month, day)

Значения параметров должны находиться в допустимых диапазонах: год от 1 до 9999, месяц от 1 до 12, а день зависит от месяца и года, например, 30 дней для апреля.

Давайте создадим новую дату:

current_date = date(2025, 11, 13)
print(current_date)
# 2025-11-13

Или с помощью метода date.today() получим текущую дату (на момент выполнения программы):

current_date = date.today()
print(current_date)
# 2025-11-13

Атрибуты year, month и day экземпляра класса date позволяют получить год, месяц и день в виде целого числа:

print(current_date.year)
# 2025
print(current_date.month)
# 11
print(current_date.day)
# 13

Класс time

Класс time используется для представления времени независимо от даты.

Объект этого класса создаётся с помощью конструктора time(), который принимает необязательные параметры hour (час), minute (минута), second (секунда) и microsecond (микросекунда):

time(hour, minute, second, microsecond)

Значения параметров должны находиться в допустимых диапазонах: час от 0 до 23, минута и секунда от 0 до 59 и микросекунда от 0 до 999999.

Если какой-то параметр не передан, то он инициализируется нулём:

lunch_time = time(14, 30)
print(lunch_time)
# Вывод: 14:30:00

У каждого экземпляра класса time есть атрибуты hour, minute, second и microsecond, которые позволяют получить час, минуту, секунду и микросекунду в виде целого числа:

print(lunch_time.hour)
# Вывод: 14
print(lunch_time.minute)
# Вывод: 30
print(lunch_time.second)
# Вывод: 0

Класс datetime

Класс datetime объединяет в себе функциональность классов date и time, представляя конкретный момент во времени.

Объект этого класса создаётся с помощью конструктора datetime(), который принимает все параметры классов date и time:

datetime(
    year, 
    month, 
    day, 
    hour=0, 
    minute=0, 
    second=0, 
    microsecond=0
)

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

print(datetime(2025, 3, 14, 12, 30))
# Вывод: 2025-03-14 12:30:00

print(datetime(2025, 10, 12))
# Вывод: 2025-10-12 00:00:00

Метод datetime.now() позволяет не задавать дату вручную, а получить текущую (для системы) дату и время:

now = datetime.now()
print(now)
# Вывод: 2025-11-14 22:37:48.613549

У экземпляров класса datetime есть все атрибуты классов date и time:

print(f"{now.year} год {now.month} месяц {now.day} день "
      f"{now.hour} часа {now.minute} минут"
)
# Вывод: 2025 год 11 месяц 14 день 22 часа 44 минут

Кроме этого, объект datetime может быть разделен на компоненты даты и времени с помощью методов:

• datetime.date() – возвращает компонент даты как объект date
• datetime.time() – возвращает компонент времени как объект time

meeting = datetime(2025, 12, 25, hour=12, minute=25)

meeting_date = meeting.date()
print(meeting_date)
# Вывод: 2025-12-25
print(type(meeting_date))
# Вывод: <class 'datetime.date'>

meeting_time = meeting.time()
print(meeting_time)
# Вывод: 12:25:00
print(type(meeting_time))
# Вывод: <class 'datetime.time'>

Класс timedelta

Класс timedelta представляет собой продолжительность или разницу между двумя моментами времени (объектами date или datetime). В отличие от классов date или datetime, которые обозначают конкретный момент во времени, timedelta обозначает протяженность времени. Поэтому в этих класса имена параметров и атрибутов пишутся в единственном числе (без «s» на конце), а в классе timedelta – во множественном числе (с «s» на конце).

Объект этого класса создаётся с помощью конструктора timedelta(), который принимает необязательные параметры days (дни), seconds (секунды), microseconds (микросекунды), milliseconds (миллисекунды), minutes (минуты), hours (часы) и weeks (недели). По умолчанию все параметры инициализированы нулём:

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

Класс timedelta хранит временной промежуток в днях, секундах и микросекундах, то есть все параметры, кроме days, seconds и microseconds, преобразуются в эти базовые единицы:

• 1 milliseconds = 1000 microseconds.
• 1 minutes = 60 seconds.
• 1 hours = 3600 seconds.
• 1 weeks = 7 days.

Благодаря этому мы можем передавать конструктору timedelta() как целые числа, так и числа с плавающей точкой:

exams = timedelta(hours=49)
print(exams)
# Вывод: 2 days, 1:00:00

holidays = timedelta(weeks=1.5, hours=21)
print(holidays)
# 11 days, 9:00:00

Несмотря на то, что такой объект выводится в консоли как дни, часы, минуты и секунды, данные он хранит в атрибутах days, seconds и microseconds, которые позволяют получить дни, секунды и микросекунды в виде целого числа:

print(holidays.days)
# Вывод: 11
print(holidays.seconds)
# Вывод: 32400
print(holidays.microseconds)
# Вывод: 0

Также мы можем получить общую продолжительность временного промежутка в секундах с помощью метода timedelta.total_seconds():

print(holidays.total_seconds())
# Вывод: 982800.0

Арифметические операции над датой и временем

Модуль datetime позволяет не только хранить дату и время, но и выполнять с ними арифметические операции. Складывать и вычитать между собой можно только объекты одного типа: date с date и datetime с datetime. Объекты класса time нельзя складывать или вычитать, так как они не привя-заны к конкретной дате.

Кроме того, объекты timedelta могут быть прибавлены к объектам date и datetime или вычтены из них.

Сложение и вычитание даты и времени между собой

Вычитание из одной даты и времени другой вычисляет разницу между ними, то есть временной промежуток timedelta:

date1 = date(2025, 10, 15)
date2 = date(2025, 10, 13)
print(date1 - date2)
# Вывод: 2 days, 0:00:00

dt1 = datetime(2025, 10, 15, hour=14)
dt2 = datetime(2025, 10, 13, hour=10, minute=15)
print(dt1 - dt2)
# Вывод: 2 days, 3:45:00

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

Также временной промежуток может быть вычтен из даты и времени или прибавлен к нему, что приведёт к сдвиганию даты назад или вперёд:

date_obj = date(2020, 12, 14)
timedelta_days = timedelta(days=2)
print(date_obj - timedelta_days)
# Вывод: 2020-12-12 (Сдвиг на 2 дня назад)
print(date_obj + timedelta_days)
# Вывод: 2020-12-16 (Сдвиг на 2 дня вперёд)

dt_obj = datetime(2025, 5, 4, hour=10, minute=5)
timedelta_weeks = timedelta(weeks=2)
print(dt_obj - timedelta_weeks)
# Вывод: 2025-04-20 10:05:00  (Сдвиг на 2 недели назад)
print(dt_obj + timedelta_weeks)
# Вывод: 2025-05-18 10:05:00 (Сдвиг на 2 недели вперёд)

Результат сложения или вычитания объекта с timedelta возвращает объект этого же класса: date или datetime.

Операции сравнения даты и времени

Объекты date, time и datetime могут быть сравнены с помощью стандартных операторов сравнения. Сравнение начинается с наибольшего компонента, например, года в date и datetime, и переходит к меньшему, то есть месяцу, дню, часу (для datetime) и так далее:

dt1 = datetime(2025, 1, 1, hour=10)
dt2 = datetime(2025, 1, 1, hour=9, minute=59)
print(dt1 > dt2) 
# Вывод: True

Сравнение останавливается при первом различии. Например, если года разные, остальные компоненты не проверяются:

date1 = date(2025, 10, 2)
date2 = date(1990, 12, 5)
print(date1 < date2) 
# Вывод: False

Преобразование даты

Работа с датами и временем редко ограничивается их хранением. Гораздо чаще требуется вывести их в понятном человеку виде (в виде строки) или, наоборот, прочитать дату из файла или ввода пользователя (разобрать строку).

Также время часто хранится как одно большое число, называемое меткой времени (англ. – timestamp). Оно представляет собой количество секунд, прошедших с 1 января 1970 года, 00:00:00. Поскольку отсчет ведется от UTC (от англ. Coordinated Universal Time – Всемирное координированное время) метка времени Unix всегда одинакова для одного и того же момента времени, независимо от того, где находится пользователь. Это значительно упрощает хранение, сравнение и передачу данных о времени между разными часовыми поясами.

Преобразование даты и времени в строку и из строки

Метод obj.strftime() преобразует объект date, time или datetime в читабельную строку в соответствии с заданным шаблоном.

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

Этот метод позволяет создать любой желаемый строковый формат из объектов с датой и временем

dt_obj = datetime(2025, 11, 16, 16, 10, 37)
format_dt = "%A, %d %B %Y. Текущее время: %H:%M:%S"
result_dt = dt_obj.strftime(format_dt)
print(result_dt)
# Вывод: Sunday, 16 November 2025. Текущее время: 16:10:37

date_obj = date(2025, 11, 16)
format_date = "Год %Y, день года №%j. Номер недели: %W"
result_date = date_obj.strftime(format_date)
print(result_date)
# Вывод: Год 2025, день года №320. Номер недели: 45

time_obj = time(16, 10, 37)
format_time = "Время: %I:%M %p. Микросекунды: %f"
result_time = time_obj.strftime(format_time)
print(result_time)
# Вывод: Время: 04:10 PM. Микросекунды: 000000

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

Названия методов strftime() и strptime() в модуле datetime в Python кажутся очень похожими, но названия этих методов являются сокращениями от фраз «string format time» и «string parse time». То есть метод strftime() форматирует строку, а метод strptime() парсит или преобразует её в объект datetime.

Для успешного преобразования строка формата должна быть идеальным зеркалом входной строки, заменяя только значения даты и времени на соответствующие директивы (%Y, %m и так далее):

date_string = "Момент запуска: 16.11.25 в 13:55"
# Формат должен точно соответствовать строке, включая текст и разделители
format_string = "Момент запуска: %d.%m.%y в %H:%M"
dt_obj = datetime.strptime(date_string, format_string)
print(dt_obj)
# Вывод: 2025-11-16 13:55:00

Любое несовпадение (лишний пробел, другой разделитель, отсутствие директивы) приведет к исключению ValueError.

Преобразование даты и времени в метку времени и из метки времени

Хотя для человека наиболее понятными являются форматы, такие как «1 января 2025 года», программы часто предпочитают работать с датой и временем в виде одного большого числа (метки времени).

Метод datetime.timestamp() преобразует объект datetime в число с плавающей точкой (float), представляющее секунды с начала эпохи Unix (1970-01-01 UTC):

moment = datetime(2025, 1, 1, 12, 0, 0)
ts_value = moment.timestamp() 
print(ts_value)
# Вывод: 1735722000.0

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

dt_from_ts = datetime.fromtimestamp(ts_value)
print(dt_from_ts)
# Вывод: 2025-01-01 12:00:00

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

Примеры

Пример 1. Обратный отсчет до запланированного события

Функция is_deadline(deadline) рассчитывает точное время, оставшееся до заранее установленной даты и времени deadline (например, до дедлайна проекта), и выводит результат в удобном для человека виде:

from datetime import datetime

def is_deadline(deadline: datetime) -> None:
    """Рассчитывает время, оставшееся до даты deadline.
    
    Параметры:
        deadline: Дата и время события.
    """
    # Вычисляем разницу (timedelta)
    time_left = deadline - datetime.now()

    # Проверяем, наступило ли событие
    if time_left.total_seconds() < 0:
        print("Дедлайн уже прошел!")
        return

    # Извлекаем компоненты из timedelta
    days = time_left.days
    # В seconds хранится время, не перешедшее в дни (меньше 24 часов)
    seconds_remainder = time_left.seconds 
    
    # Конвертируем остаток секунд в часы, минуты и секунды
    hours = seconds_remainder // 3600
    minutes = (seconds_remainder % 3600) // 60
    seconds = seconds_remainder % 60
    print(f"Осталось {days} дней, {hours} часов, {minutes} минуты и {sec-onds} секунд")


deadline = datetime(2026, 3, 15, 18, 0, 0) # 15 марта 2026 года, 18:00:00
is_deadline(deadline)

Вывод:

Осталось: 105 дней, 16 часов, 48 минут и 0 секунд

Пример 2. Расчёт возраста человека

Функция get_age(birth_date) рассчитывает возраст человека, рождённого в дату birth_date, как количество прожитых лет, дней и секунд:

from datetime import date

def get_age(birth_date: date) -> None:
    """Выводит на экран информацию о возрасте человека 
    и количестве его прожитого времени.
    
    Параметры:
        birth_date: Дата рождения человека.
    """ 
    print(f"День рождения: {birth_date}")
    print(f"Текущая дата: {date.today()}")
    
    # Вычисляем разницу в виде timedelta
    duration = date.today() - birth_date
    total_days = duration.days

    # Приближенный расчет возраста
    approx_years = int(total_days // 365.25) # Учет високосных годов
    remaining_days = int(total_days % 365.25) 

    # Общее количество секунд
    total_seconds = int(duration.total_seconds())

    print(f"Примерный возраст: {approx_years} лет и {remaining_days} дней")
    print(f"Общее количество прожитых дней: {total_days}")
    print(f"Общее количество прожитых секунд: {total_seconds}")


birth_date = date(1995, 8, 20)  # 20 августа 1995 года
get_age(birth_date)

Вывод:

День рождения: 1995-08-20
Текущая дата: 2025-12-28
Примерный возраст: 30 лет и 130 дней
Общее количество прожитых дней: 11088
Общее количество прожитых секунд: 958003200

Пример 3. Генерация списка дат с заданным интервалом

Функция get_date_series(start_date, interval, series_length) генерирует список из series_length дат, начиная с даты start_date, с интервалом interval между каждой датой:

from datetime import date, timedelta

def get_date_series(
    start_date: date, 
    interval: timedelta, 
    series_length: int
) -> list:
    """Генерирует список дат с заданным интервалом.
    
    Параметры:
        start_date: Начальная дата.
        interval: Интервал между датами.
        series_length: Количество дат в списке.
        
    Возвращает:
        Список из series_length дат.
    """
    # Цикл для генерации 10 дат
    date_series = []
    current_date = start_date
    for i in range(series_length):
        date_series.append(current_date)
        # Добавление временного интервала к дате
        current_date += interval
    
    return date_series

start_date = date(2025, 11, 30)
interval = timedelta(weeks=2)  # 2 недели
date_series = get_date_series(start_date, interval, 10)
for i, d in enumerate(date_series):
    # %d.%m.%Y - Формат ДД.ММ.ГГГГ
    print(f"Дата {i+1}: {d.strftime('%d.%m.%Y')}")

Вывод:

Дата 1: 30.11.2025
Дата 2: 14.12.2025
Дата 3: 28.12.2025
Дата 4: 11.01.2026
Дата 5: 25.01.2026
Дата 6: 08.02.2026
Дата 7: 22.02.2026
Дата 8: 08.03.2026
Дата 9: 22.03.2026
Дата 10: 05.04.2026

Итоги

• Модуль datetime предоставляет классы для работы с датой и временем.
• Класс date используется для представления даты.
• Метод date.today() возвращает текущую дату (без времени).
• Класс time используется для представления времени.
• Класс datetime используется для представления даты и времени.
• Метод datetime.now() возвращает текущую дату и время
• Метод datetime.date() возвращает дату из объекта datetime.
• Метод datetime.time() возвращает время из объекта datetime.
• Класс timedelta представляет собой продолжительность или разницу между двумя моментами времени (объектами date или datetime).
• Метод timedelta.total_seconds() возвращает общую продолжительность промежутка в секундах.
• Вычитание из одного объекта даты и времени другого вычисляет разницу между ними, то есть временной промежуток timedelta.
• Промежуток времени timedelta может быть прибавлен или вычтен из объектов date и datetime.
• Дату и время можно сравнивать с помощью стандартных операторов сравнения (от большего компонента к меньшему).
• Метод obj.strftime() преобразует объект объект date, time или datetime в читаемую строку в соответствии с заданным шаблоном.
• Метод datetime.strptime() преобразует строку с датой и временем в объект datetime.

Задания для самопроверки

1. Можно ли из существующего объекта datetime получить компонент даты (объект date) и компонент времени (объект time)?

2. Создайте две даты: дату начала проекта start_date = date(2025, 1, 15) и дату его завершения end_date = date(2025, 5, 20). Вычислите разницу длительность проекта и выведите его на экран.

from datetime import date

start_date = date(2025, 1, 15)
end_date = date(2025, 5, 20)
time_difference = end_date - start_date
print(time_difference)
# Вывод: 125 days, 0:00:00

3. Дана строка с датой и временем date_str = "23 January 2026, 14:30". Преобразуйте эту строку в объект datetime и выведите её на экран.

from datetime import datetime

date_str = "23 January 2026, 14:30"
format_str = "%d %B %Y, %H:%M"  # Формат: День Месяц Год, Час:Минута
datetime_obj = datetime.strptime(date_str, format_str)
print(datetime_obj)
# Вывод: 2026-01-23 14:30:00

4. Получите текущую дату и время и преобразуйте этот объект в строку в следующем формате: "Сегодня: %A, %d.%m.%Y. Время: %H:%M:%S". Выведите на экран отформатированную строку.

from datetime import datetime

current_dt = datetime.now()
formatted_string = current_dt.strftime("Сегодня: %A, %d.%m.%Y. Время: %H:%M:%S")
print(formatted_string)
# Вывод: Сегодня: Friday, 19.12.2025. Время: 01:11:37

5. Напишите функцию is_event_passed(event_dt), которая принимает объект datetime (дату события event_dt) и сравнивает его с текущим моментом (datetime.now()). Функция должна вернуть True, если событие уже прошло, и False, если оно произойдёт в будущем. Вызовите эту функцию для двух произвольных дат и выведите результаты на экран.

from datetime import datetime

def is_event_passed(event_dt: datetime) -> bool:
    current_time = datetime.now()
    # Если дата события (event_dt) меньше (<), значит, событие уже прошло
    return event_dt < current_time


past_dt = datetime(2025, 12, 17, 10, 0, 0)  # Событие в прошлом 
print(f"Событие {past_dt} уже прошло: {is_event_passed(past_dt)}")
# Вывод: Событие 2025-12-17 10:00:00 уже прошло: True

future_dt = datetime(2026, 12, 1, 10, 0, 0)  # Событие в будущем
print(f"Событие {past_dt} уже прошло: {is_event_passed(future_dt)}")
# Вывод: Событие 2025-12-17 10:00:00 уже прошло: False