Python работа с датами: Работа с датой и временем в модуле Python datetime

Python | Операции с датами

Операции с датами

Последнее обновление: 05.05.2017

Фоматирование дат и времени

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

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

• %a: аббревиатура дня недели. Например, Wed — от слова Wednesday (по умолчанию используются английские наименования)

• %A: день недели полностью, например, Wednesday

• %b: аббревиатура названия месяца. Например, Oct (сокращение от October)

• %B: название месяца полностью, например, October

• %d: день месяца, дополненный нулем, например, 01

• %m: номер месяца, дополненный нулем, например, 05

• %y: год в виде 2-х чисел

• %Y: год в виде 4-х чисел

• %H: час в 24-х часовом формате, например, 13

• %I: час в 12-ти часовом формате, например, 01

• %M: минута

• %S: секунда

• %f: микросекунда

• %p: указатель AM/PM

• %c: дата и время, отформатированные под текущую локаль

• %x: дата, отформатированная под текущую локаль

• %X: время, форматированное под текущую локаль

Используем различные форматы:

from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d"))             # 2017-05-03
print(now.strftime("%d/%m/%Y"))             # 03/05/2017
print(now.strftime("%d/%m/%y"))             # 03/05/17
print(now.strftime("%d %B %Y (%A)"))        # 03 May 2017 (Wednesday)
print(now.strftime("%d/%m/%y %I:%M"))       # 03/05/17 01:36

При выводе названий месяцев и дней недели по умолчанию используются английские наименования. Если мы хотим использовать текущую локаль, но то мы
можем ее предварительно установить с помощью модуля locale:

from datetime import datetime
import locale
locale.setlocale(locale.LC_ALL, "")

now = datetime.now()
print(now.strftime("%d %B %Y (%A)"))        # 03 Май 2017 (среда)

Сложение и вычитани дат и времени

Нередко при работе с датами возникает необходимость добавить к какой-либо дате определенный промежуток времени или, наоборот, вычесть некоторый период. И специально для
таких операций в модуле datetime определен класс timedelta. Фактически этот класс определяет некоторый период времени.

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

timedelta([days] [, seconds] [, microseconds] [, milliseconds] [, minutes] [, hours] [, weeks])

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

Определим несколько периодов:

from datetime import timedelta

three_hours = timedelta(hours=3)
print(three_hours)       # 3:00:00
three_hours_thirty_minutes = timedelta(hours=3, minutes=30)  # 3:30:00

two_days = timedelta(2)  # 2 days, 0:00:00

two_days_three_hours_thirty_minutes = timedelta(days=2, hours=3, minutes=30)  # 2 days, 3:30:00

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

from datetime import timedelta, datetime

now = datetime.now()
print(now)                      # 2017-05-03 17:46:44.558754
two_days = timedelta(2)
in_two_days = now + two_days
print(in_two_days)              # 2017-05-05 17:46:44.558754

Или узнаем, сколько было времени 10 часов 15 минут назад, то есть фактически нам надо вычесть из текущего времени 10 часов и 15 минут:

from datetime import timedelta, datetime

now = datetime.now()
till_ten_hours_fifteen_minutes = now - timedelta(hours=10, minutes=15)
print(till_ten_hours_fifteen_minutes) 

Свойства timedelta

Класс timedelta имеет несколько свойств, с помощью которых мы можем получить временной промежуток:

• days: возвращает количество дней

• seconds: возвращает количество секунд

• microseconds: возвращает количество микросекунд

Кроме того, метод total_seconds() возвращает общее количество секунд, куда входят и дни, и собственно секунды, и микросекунды.

Например, узнаем какой временной период между двумя датами:

from datetime import timedelta, datetime

now = datetime.now()
twenty_two_may = datetime(2017, 5, 22)
period = twenty_two_may - now
print("{} дней  {} секунд   {} микросекунд".format(period.days, period.seconds, period.microseconds))
# 18 дней  17537 секунд   72765 микросекунд

print("Всего: {} секунд".format(period.total_seconds()))
# Всего: 1572737.072765 секунд

Сравнение дат

Также как и строки и числа, даты можно сравнивать с помощью стандартных операторов сравнения:

from datetime import datetime

now = datetime.now()
deadline = datetime(2017, 5, 22)
if now > deadline:
    print("Срок сдачи проекта прошел")
elif now.day == deadline.day and now.month == deadline.month and now.year == deadline.year:
    print("Срок сдачи проекта сегодня")
else:
    period = deadline - now
    print("Осталось {} дней".format(period.days))

12 советов для работы с датой и временем

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

1. Во первых, давайте импортируем библиотеку datetime и создадим три разных объекта:

• Объект date – для хранения даты;
• Объект time – для хранения времени;
• Объект datetime – для хранения и даты и времени.

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

import datetime
now = datetime.datetime.now()
today = now.date()
moment = now.time()

Если вы впишете все вышеуказанное, вы получите что-то на подобие следующего:

print(now) # datetime.datetime(2017, 4, 14, 16, 38, 46, 271475)
print(today) # datetime.date(2017, 4, 14)
print(moment) # datetime.time(16, 38, 46, 271475)

Здесь мы видим, что время 16 часов 46 минут и 46.171475 секунду, и сегодня 14 Апреля 2017.

2. Вы также можете создать объекты date и time и получить объект datetime python, при помощи метода комбинирования:

today = datetime.date.today()
moment = datetime.datetime.now().time()
now = datetime.datetime.combine(today, moment)

3. Еще один интересный объект, это timedelta, который используется для суммирования или вычитания количества дней:

yesterday = today - datetime.timedelta(1)

Или он может хранить разницу между двумя объектами datetime:

delta = yesterday - today

4. Объекты даты имеют три обязательных аргумента (вы можете изменить их порядок при помощи ключей):

my_date = datetime.date(1984, 6, 24)
my_date = datetime.date(day=24, year=1984, month=6)

5. Объекты времени не имеют обязательных аргументов. Эти три оператора являются эквивалентом:

my_time = datetime.time() 
my_time = datetime.time(0,0) # Час, Минута
my_time = datetime.time(hour=0, minute=0)

6. Изменение одного объекта datetime для получения другого, при помощи метода replace:

another_datetime = my_datetime.replace(year=2014, month=1)

7. Получение объекта datetime, представляющий эпоху 01-01-1970:

epoch = datetime.datetime.utcfromtimestamp(0)

8. Получение количества дней и секунд между эпохой и сейчас, а также получение общего количества прошедших секунд:

delta = now - epoch
days = delta.days
 
seconds = delta.seconds
total_seconds = delta.total_seconds()

9. Восстановление объекта, с использованием количества секунд начиная с эпохи при помощи метода utcfromtimestamp:

now = datetime.datetime.utcfromtimestamp(seconds)

10. Создаем объект date как “1984-06-24”:

string_date = str(my_date)

11. Восстановление объекта со строки, на подобие “1984-06-24”:

my_date = datetime.date(*[int(i) for i in string_date.split("-")])

12. Пишем объект date с настроенным форматом строки при помощи метода strftime:

string_date =  my_date.strftime('%m/%d/%Y')  # Выводит: "06/24/1984"

Спасибо за внимание, надеюсь, эта статья поможет вам при работе с датой и временем в Python!

Манипуляции с датой и временем в Python с помощью библиотеки Pandas

Работать с датой и временем несложно, но нужно запомнить много справочной информации. В этой статье мы рассмотрим большую ее часть. Для демонстрации используется стандартная библиотека Python datetime и Pandas.

Основы библиотеки DateTime

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

Или, если вам она нужна, можно указать значения.

Чтобы узнать, сколько сейчас времени до миллисекунды, можно использовать функцию .now().

Разница во времени

Объявим переменную и установим ее значение на текущее время.

Затем объявим другую переменную и устанавливаем ее значение на текущее время минус значение переменной current_time.

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

Перевод string в в datetime и наоборот

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

Если вас не устраивает форматирование, зайдите на этот сайт. Для обратного преобразования используется метод strftime().

Диапазоны дат в Pandas

При работе с датами я чаще использую библиотеку Python datetime. Но кроме этих случаев:

• диапазоны дат;
• пересчет времени.

Второй случай заслуживает отдельной статьи, поэтому я остановлюсь на первом.

Я использую библиотеку Pandas для создания диапазонов дат, чтобы избежать циклов при использовании стандартной библиотеки. Например, чтобы создать 30-дневный массив дат, начинающийся с 1 января 2020 года.

Видите, как легко?

При этом не нужно придерживаться определенного форматирования. Библиотека Pandas достаточно умна, чтобы понять, что именно вы имели в виду

Это также будет отлично работать.

Даже какая-то сумасшедшая комбинация не будет проблемой.

И напоследок

Этих знаний достаточно для объявления даты и времени и работы с ними в Python. Их достаточно для выполнения большинства задач.

Данная публикация представляет собой перевод статьи «Mastering Date and Time Manipulations with Python and Pandas» , подготовленной дружной командой проекта Интернет-технологии.ру

телеграм канал. Подпишись, будет полезно!

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

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

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

Мы также узнаем, как настроить дату и время для разных часовых поясов. Наконец, мы рассмотрим преобразование объектов datetime в популярные метки времени Unix или Epoch.

Получение текущей даты и времени с datetime

Модуль datetime содержит различные классы, чтобы получить информацию о дате и времени:

1. datetime.date: Хранит день, месяц и год
2. datetime.time: Хранит время в часах, минутах, секундах и микросекундах. Эта информация не зависит от даты
3. datetime.datetime: Хранит атрибуты date и time

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

from datetime import datetime

Поначалу это выглядит странно, но мы получаем класс datetime из модуля datetime, это две разные вещи.

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

current_datetime = datetime.now()
print(current_datetime)

Запуск этого файла даст нам следующий вывод:

2019-12-13 12:18:18.290623

Функция now() дала нам объект со всей датой и временем его создания. Когда мы его печатаем, Python автоматически форматирует объект в строку, чтобы люди могли его легко прочитать. 

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

print(current_datetime.year)            # 2019
print(current_datetime.month)           # 12
print(current_datetime.day)             # 13
print(current_datetime.hour)            # 12
print(current_datetime.minute)          # 18
print(current_datetime.second)          # 18
print(current_datetime.microsecond)     # 290623

Метод now() идеально подходит для захвата текущего времени и даты. Однако, это излишне, когда вы заботитесь только о дате или времени, но не обоих. Как мы можем получить только информацию о дате?

Получение текущей даты

Есть два способа получить текущую дату в Python. В консоли Python мы можем получить дату из объекта datetime с помощью метода date():

>>> from datetime import datetime
>>> current_date = datetime.now().date()
>>> print(current_date)
2019-12-13

Тем не менее, это кажется пустой тратой на инициализацию объекта datetime только для захвата даты. Альтернативой может быть использование метода today() класса date:

>>> from datetime import date
>>> current_date = date.today()
>>> print(current_date)
2019-12-13

Класс datetime.date представляет собой календарную дату. Его атрибуты year, month и day могут быть доступны так же, как мы обращаемся к ним в объекте datetime.

Например, этот оператор print получает каждый атрибут, а также использует метод weekday() для получения дня недели:

>>> print("It's the %dth day of the week, %dth day of the %dth month of the %dth year" %
... (current_date.weekday()+1, current_date.day, current_date.month, current_date.year))
It's the 5th day of the week, 13th day of the 12th month of the 2019th year

Примечание: Метод weekday() возвращает целое число от 0 до 6 для представления дня недели. 0 соответствует понедельнику. Поэтому в нашем примере мы добавили 1, чтобы напечатать 5-й день недели (пятница), хотя метод weekday() вернул 4.

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

Получение текущего времени

Мы фиксируем текущее время от объекта datetime, используя метод time():

>>> from datetime import datetime
>>> current_time = datetime.now().time()
>>> print(current_time)
12:18:18.290623

В отличие от получения дат, здесь нет ярлыка для непосредственного отображения текущего времени. Класс datetime.time представляет собой понятие времени как в часах, минутах, секундах и микросекунд — все, что меньше, чем один день.

Как и объект datetime, мы можем получить доступ к его атрибутам напрямую. Вот пример, как мы печатаем current_time в предложении:

>>> print("It's %d o'clock. To be exact, it's %d:%d and %d seconds with %d microseconds" %
... (current_time.hour, current_time.hour, current_time.minute, current_time.second, current_time.microsecond))
It's 12 o'clock. To be exact, it's 12:18 and 18 seconds with 290623 microseconds

По умолчанию функция now() возвращает время вашего местного часового пояса. Что если нам нужно будет преобразовать его в другой, который был установлен в настройках пользователя? Давайте посмотрим, как мы можем предоставить информацию о часовом поясе для получения локализованных объектов time.

Получение текущей даты и времени в другом часовом поясе

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

Установите библиотеку pytz:

Теперь давайте используя pytz получим текущую дату и время, если бы мы были в Берлине:

>>> import pytz
>>> from datetime import datetime
>>> tz = pytz.timezone('Europe/Berlin')
>>> berlin_current_datetime = datetime.now(tz)
>>> print(berlin_current_datetime)
2019-12-14 00:20:50.840350+01:00

berlin_current_datetime будет объектом datetime со всеми свойствами и функциями, которые мы видели ранее, но теперь он полностью соответствует часовому поясу Берлина.

Если вы хотите узнать время в UTC, вы можете использовать модуль pytz, как и раньше:

>>> import pytz
>>> from datetime import datetime
>>> utc_current_datetime = datetime.now(pytz.timezone("UTC"))
>>> print(utc_current_datetime)
2019-12-13 23:20:50.840350+00:00

Кроме того, для времени UTC вам не нужно использовать модуль pytz вообще. Модуль datetime имеет свойство timezone, которое может быть использовано, как в примере:

>>> from datetime import datetime, timezone
>>> utc_current_datetime = datetime.now(timezone.utc)
>>> print(utc_current_datetime)
2019-12-13 23:20:50.840350+00:00

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

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

Компьютерные системы измеряют время на основе количества секунд, прошедших с начала эпохи Unix, то есть 00:00:00 UTC 1 января 1970 года. Приложения, базы данных и протоколы обычно используют временную метку для отображения времени.

Вы можете получить текущую метку времени в Python, используя модуль time:

>>> import time
>>> print(time.time())
1576280665.0915806

Функция time.time() возвращает число с плавающей запятой с меткой времени Unix. Вы можете преобразовать метку времени в объект datetime, используя функцию fromtimestamp():

>>> from datetime import datetime
>>> print(datetime.fromtimestamp(1576280665))
2019-12-13 19:44:25

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

Например, чтобы преобразовать метку времени в объект datetime в формате UTC, вы можете сделать это:

>>> from datetime import datetime, timezone
>>> print(datetime.fromtimestamp(1576280665, timezone.utc))
2019-12-13 19:44:25+00:00

И наоборот, вы можете использовать метод timestamp() для преобразования объекта datetime в допустимую метку времени:

>>> from datetime import datetime, timezone
>>> print(datetime.now(timezone.utc).timestamp())
1577117555.940705

Вывод

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

По умолчанию Python создает объекты datetime в нашем местном часовом поясе. Если мы используем библиотеку pytz, мы можем конвертировать даты и время в разные часовые пояса.

Наконец, мы использовали функцию fromtimestamp() для получения метки времени Unix для получения объекта datetime. Если у нас есть объект datetime, мы можем получить метку времени, используя его метод timestamp().

Модуль time в Python 3 — получение текущего времени

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

Текущее время в Python

Работа методов из модуля time основывается на общепринятой системе описания времени, которая справедлива для Unix, а также для POSIX-совместимых ОС. Согласно ее концепции, текущее время представляется в виде обыкновенного вещественного значения в секундах, прошедших с момента начала эпохи и до сегодняшнего дня. Отправной точкой для времени считается 1 января 1970 года, когда счетчик секунд имел полностью нулевое значение.

С тех пор это число постоянно растет, позволяя людям работать с различными видами дат в максимально точном представлении. В случае необходимости секунды переводятся в часы, дни, месяцы и годы, предоставляя пользователю удобный вид отображения времени. Чтобы увидеть количество секунд, прошедших с момента начала эпохи, достаточно вызвать метод time(). Но перед этим необходимо подключить модуль time с помощью операции импорта.

import time
print(time.time())

1540289822.637441

Как можно увидеть из данного примера, функция print получает в качестве единственного параметра число, возвращенное из метода time(), после чего выводит его на экран. Таким образом, с 1 января 1970 года прошло уже более полтора миллиарда секунд. Но подобное представление времени совсем неудобно для пользователя программы. Чтобы отобразить текущую дату в более комфортном виде, стоит передать функции print результат работы метода ctime(), не забыв произвести импорт соответствующей ему библиотеки time.

import time
print(time.ctime())

Tue Oct 23 10:18:23 2018

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

Методы

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

Форматированный вывод

Принцип работы метода ctime() заключается в представлении секундного вещественного значения в более удобном виде, благодаря автоматическому форматированию. Некоторым пользователям предложенный подобным образом вывод данных может показаться чересчур сложным для восприятия либо же недостаточно информативным. Именно поэтому методы модуля time позволяют создавать свои уникальные типы форматирования для дат. В данном случае речь пойдет о функции strftime, принимающей в качестве параметров текущее время и шаблон, который будет использоваться для форматирования полученного объекта.

В следующем примере демонстрируется вывод значения, переданного функцией localtime() в strftime. То есть, мы в Python получим текущее время и выведем его в отформатированном виде. Первым аргументом метода strftime является строка с некоторым набором правил для форматирования, каждое из которых указано при помощи символа %. В результате, на экране выводится информация, включающая название месяца, число и год.

import time
print(time.strftime("Today is %B %d, %Y.", time.localtime()))

Today is October 23, 2018.

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

Применение метода sleep

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

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

import time
pause = 10
print("Program started...")
time.sleep(pause)
print(str(pause) + " seconds passed.")

Program started...
10 seconds passed.

Как можно увидеть из результатов выполнения кода, вначале на экран выводится стартовое сообщение, после чего программа прекращает свою работу ровно на 10 секунд, поскольку метод sleep получает переменную pause в качестве аргумента. Затем отображается последняя запись, информирующая пользователя о том, какое количество секунд длилась задержка.

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

Таким образом, чтобы сделать задержку в 100 миллисекунд, надо написать time.sleep(0.1).

Время выполнения программы

Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов time() для получения текущего времени, чтобы в конечном итоге выявить, как долго работал блок кода. Метод sleep() здесь увеличивает время выполнения программы на 5 секунд.

import time
start = time.time()
time.sleep(5)
finish = time.time()
result = finish - start
print("Program time: " + str(result) + " seconds.")

Program time: 5.005090236663818 seconds.

Несмотря на простоту вышеописанного подхода, использовать его в серьезных целях, где требуется точный и независимый от ОС результат, не рекомендуется. Все дело в том, что числовое значение времени, получаемое таким образом, может иметь погрешности за счет внутренних особенностей работы компьютера, в среде которого выполняется программа. Например, системные часы могут быть подкорректированы вручную пользователем во время выполнения программы. Корректировка может произойти и автоматически, если настроена синхронизация системных часов по NTP.

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

monotonic

По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.

import time
start = time.monotonic()
time.sleep(15)
result = time.monotonic() - start
print("Program time: {:>.3f}".format(result) + " seconds.")

Program time: 15.012 seconds.

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

Заключение

Используя стандартный библиотечный модуль time в Python 3, можно всячески взаимодействовать с информацией о текущем времени. Таким образом, использование библиотеки дает возможность:

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

практическое руководство по путешествию во времени с Python

Как в Python вывести строку, содержащую текущие дату и время? Как вычислить время, прошедшее между двумя днями? Как измерить длительность выполнения фрагмента кода? Как сгенерировать календарь на весь год или на один месяц? Как определить даты всех третьих четвергов одного года? На эти и другие вопросы вы получите ответы в данном руководстве.

Чтобы не обращаться далее к операции импорта, перечислим сразу все встроенные модули, рассматриваемые в этом руководстве:

        >>> import time
>>> import timeit
>>> import datetime
>>> import calendar
    

1. Работа со шкалой времени: модуль time

1.1. Понятие epoch

Работа с модулем time в существенной мере зависит от используемой операционной системы. Время в библиотеке привязано к фиксированной начальной точке – эпохе (epoch). Узнаем эту начальную точку:

        >>> time.gmtime(0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
    

В Unix-системах точкой отсчета (epoch) является 1 января 1970 г. Функция gmtime() вернула объект именованного кортежа struct_time.

С помощью функции time() время, прошедшее с этой начальной точки, можно также вывести в секундах (seconds since the epoch):

        >>> time.time()
1575098265.8943102
    

Так как точка epoch для разных операционных систем может отличаться, число секунд, возвращаемое функцией time(), также может быть различным.

Время до точки epoch тоже существует, но значения секунд seconds since the epoch отрицательны. Если мы передадим функции gmtime отрицательное значение секунд, мы перенесемся в прошлое относительно момента времени epoch:

        >>> time.gmtime(-10**8)
time.struct_time(tm_year=1966, tm_mon=10, tm_mday=31, tm_hour=14, tm_min=13, tm_sec=20, tm_wday=0, tm_yday=304, tm_isdst=0)
    

1.2. Секунды, struct_time и преобразование друг в друга

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

1. gmtime(): из секунд в struct_time для UTC.
2. localtime(): из секунд в struct_time для местного времени.
3. calendar.timegm() (не модуль time): из struct_time для UTC в секунды.
4. mktime(): из struct_time местного времени в секунды.

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

        >>> time.gmtime(1574869797)
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=27, tm_hour=15, tm_min=49, tm_sec=57, tm_wday=2, tm_yday=331, tm_isdst=0)
    

        >>> time.localtime(1574869797)  # заметьте отличие в выводе значения tm_hour
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=27, tm_hour=18, tm_min=49, tm_sec=57, tm_wday=2, tm_yday=331, tm_isdst=0)
    

В отсутствии аргумента функции gmtime() и localtime() возвращают значение для текущего времени – соответственно UTC и местное время.

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

1. Год tm_year
2. Месяц tm_mon – целое число (1 – Январь, 12 – Декабрь)
3. День месяца tm_day
4. Час tm_hour – целое число в диапазоне от 0 до 23
5. Минута tm_min
6. Секунда tm_sec
7. День недели tm_wday – целое число от 0 (Понедельник) до 6 (Воскресенье)
8. День года tm_yday
9. Целочисленный флаг tm_isdst для учета перехода на летнее время (daylight saving time, DST): 1 – переход на летнее время учитывается, 0 – не учитывается, -1 – неизвестно

        >>> time.mktime((2015, 10, 21, 7, 28, 0, 2, 294, -1))
1445401680.0
    

Очевидно, что составлять такой кортеж вручную – задача неблагодарная, ведь нужно знать и день недели, и номер дня в году. Обычно используются «готовые» объекты (для «ручного» формирования дат удобнее применять описанный далее модуль datetime):

        >>> time.mktime(time.localtime())
1575099022.0
    

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

        >>> calendar.timegm(time.gmtime())
1575099039
    

Заметим, что, в отличие от представления в виде секунд, struct_time не хранит составляющих времени, меньших, чем секунда.

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

        >>> t = time.localtime()
>>> 'Итак, на дворе {}-й год.'.format(t.tm_year)
    

Кроме вышеперечисленных параметров-меток, struct_time содержит скрытые. Так, местным законодательством каждой страны регулируется переход на летнее время. Узнать, действует ли сейчас летнее время, можно следующим образом (в России в 2014 году произведен переход на постоянное «зимнее» время):

        >>> t.tm_isdst
0
    

Считаем часовой пояс:

        >>> t.tm_zone
'MSK'
    

Смещение местного времени относительно UTC в секундах:

        >>> t.tm_gmtoff
1
    

1.3. Строки временных меток

Распространенная задача – преобразование объектов указанных типов в строки вида timestamp, например, Mon Dec 2 18:30:20 2019. Для этого применяются функции ctime() и asctime():

• ctime() – принимает время в секундах
• asctime() – принимает struct_time (по умолчанию используется местное время)

        >>> time.ctime(time.time())  # преобразует время в секундах в timestamp для местного времени
'Sat Nov 30 10:37:11 2019'
>>> time.asctime()  # Аналогично time.asctime(time.localtime())
'Sat Nov 30 11:05:01 2019'
>>> time.asctime(time.gmtime())  # Время UTC
'Sat Nov 30 08:05:28 2019'
    

Хотя строковый вывод функций ctime() и asctime() довольно удобен, может потребоваться альтернативный формат. Для гибкого форматирования в библиотеку time включена функция strftime(). Функция принимает строку шаблона форматирования со спецификаторами и сам объект времени.

        >>> time.strftime('%d.%m.%Y', time.localtime())
'30.11.2019'
    

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

        >>> import locale
>>> locale.setlocale(locale.LC_TIME, 'ru_RU.utf8')
>>> time.strftime('Текущее время: %c', time.localtime())
'Текущее время: Сб 30 ноя 2019 11:07:41'
    

Список спецификаторов шаблона:

• %a, %A – аббревиатура и полное название дня недели (Чт, Четверг)
• %b, %B – то же для месяца с учетом склонения (ноя, ноября)
• %с – локализованная строка временной метки
• %d – день месяца (28)
• %H, %I – Час в 24- и 12-часовом представлении (17, 05)
• %j – номер дня года (в представлении от 001 до 366)
• %m – двузначное представление месяца (от 01 до 12)
• %M – двузначное представление минут (от 00 до 59)
• %p – местный эквивалент AM и PM
• %S – двузначное представление секунд
• %W – двузначное представление номера недели, первый день – Пн (%U для Вс)
• %w – двузначное представление номера дня недели
• %x, %X – принятый способ представления даты и времени.
• %y, %Y – двузначное (без века) и четырехзначное представление года
• %z, %Z – обозначение часового пояса в четырехзначном формате со знаком плюс или минус и в виде названия часового пояса

Пример одновременного использования нескольких спецификаторов:

        s = """Сегодня %A, %d %B. В России эту дату обычно записывают
следующим образом: %x или сокращенно: %d.%m.%y.
Это %j день года, %W неделя. На часах %X.
Часовой пояс: %Z."""

print(time.strftime(s, time.localtime()))
    

Что, если у нас есть строка, содержащая метку времени, а мы хотим распарсить ее в объект struct_time, чтобы обработать его в Python? Для этого есть функция strptime(). Первый аргумент – строка, второй – правило, описанное через те же спецификаторы:

        >>> time.strptime('Окт 21 2015 07:28', '%b %d %Y %H:%M')
time.struct_time(tm_year=2015, tm_mon=10, tm_mday=21, tm_hour=7, tm_min=28, tm_sec=0, tm_wday=2, tm_yday=294, tm_isdst=-1)
    

Функция strptime() позволяет кратко задавать struct_time, не используя все девять позиций кортежа. Неизвестные элементы вычисляются или на их место подставляются значения по умолчанию.

1.4. Приостановка выполнения кода и оценка производительности

Одна из наиболее часто используемых функций модуля time – функция sleep(), выполняющая задержку исполнения программного кода на переданное число секунд (можно использовать дробные значения):

        print(time.strftime('Текущее время: %X.'))
print('Задержка...')
time.sleep(5)
print('Прошло время.')
print(time.strftime('Текущее время: %X.'))
    

        Текущее время: 11:19:30.
Задержка...
Прошло время.
Текущее время: 11:19:35.
    

Функция sleep() нередко используется для тестирования кода, намеренного внесения задержек на различных этапах выполнения программы.

Для оценки производительности однократно запускаемых команд применяется функция perf_counter(), обеспечивающая лучшее разрешение по времени на коротких интервалах:

        def longrunning_function():
    for i in range(3):
        time.sleep(1)
        
def shortrunning_function():
    n = 1
    for i in range(2, 100):
        n *= i

start = time.perf_counter()
longrunning_function()
end = time.perf_counter()
print("Выполнение longrunning_function() заняло {} c.".format(end-start))

start = time.perf_counter()
shortrunning_function()
end = time.perf_counter()
print("Выполнение shortrunning_function() заняло {} c.".format(end-start))
    

        Выполнение longrunning_function() заняло 3.0040391949996774 c.
Выполнение shortrunning_function() заняло 0.00023569400036649313 c.
    

В Python версии 3.7 добавлена функция perf_counter_ns() – работает так же, но длительность выводится в наносекундах, что удобнее для совсем малых интервалов времени и быстро исполняемых команд.

Более удобные методы для измерения производительности фрагмента кода предоставляет модуль timeit.

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

У модуля timeit есть интерфейс командной строки и интерфейс для вызова в коде. Во втором случае выводится время в секундах, которое длится общее количество запусков. Так как значение number по умолчанию составляет 1 млн повторений, можно считать, что при дефолтном запуске выводится среднее время операции в микросекундах. При вызове timeit в командной строке достаточное количество повторений определяется автоматически.

Сравним скорость выполнения операция конкатенации при использовании генератора и функции map():

        $ python3 -m timeit '"-".join(str(n) for n in range(100))'
100000 loops, best of 3: 14.6 usec per loop
$ python3 -m timeit '"-".join(map(str, range(100)))'
100000 loops, best of 3: 9.72 usec per loop
    

Сравним с вызовом через интерпретатор Python:

        >>> timeit.timeit('"-".join(str(n) for n in range(100))')
15.504044628999509
>>> timeit.timeit('"-".join(map(str, range(100)))')
10.823708094999347

    

Кроме куска кода, функции timeit() можно передать строку setup, однократно выполняемую перед началом повторения кода stmt. В setup, например, можно вынести импорт библиотек:

        mysetup = 'from math import sqrt'

mycode = '''
mylist = []
for i in range(100):
    mylist.append(sqrt(i))
'''
        
timeit.timeit(stmt = mycode,
              setup = mysetup,
              number = 10000)
    

        0.09423511200020585
    

В блокнотах Jupyter команда timeit относится к числу магических. С одним знаком процента она действует в пределах строки кода, с двумя – в границах ячейки:

        %timeit s = "-".join(str(n) for n in range(100))
    

        15.3 µs ± 276 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
    

        %%timeit
mylist = []
for i in range(100):
    mylist.append(i**0.5)
    

        14.5 µs ± 369 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
    

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

        %time s = "-".join(str(n) for n in range(100))
    

        CPU times: user 104 µs, sys: 1e+03 ns, total: 105 µs
Wall time: 113 µs
    

        %%time
mylist = []
for i in range(100):
    mylist.append(i**0.5)
    

        CPU times: user 119 µs, sys: 1e+03 ns, total: 120 µs
Wall time: 130 µs
    

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

Структура представления времени в datetime похожа на struct_time в модуле time:

        >>> t = datetime.datetime.now()
>>> t
datetime.datetime(2019, 11, 30, 12, 7, 58, 431007)
>>> print(t)
2019-11-30 12:07:58.431007
    

Выведем отдельно дату и время:

        >>> print('Сегодня {}. Время: {}.'.format(t.date(), t.time()))
Сегодня 2019-11-30. Время: 12:07:58.431007.
    

Аналогично извлекаются год, месяц и т.д.:

        "Год {}, месяц {}, день {}, {} ч. {} мин. {} сек.".format(t.year,
                                                          t.month,
                                                          t.day,
                                                          t.hour,
                                                          t.minute,
                                                          t.second)
    

Модуль datetime также удобен для «ручного» задания дат и автоматизации арифметических операций с датами. Узнаем интервал времени между двумя главными датами сюжета фильма «Назад в будущее 2»:

        >>> today = datetime.datetime(year=1985, month=10, day=26, hour=21, minute=0)
>>> future = datetime.datetime(year=2015, month=10, day=21, hour=19, minute=28)
>>> delta = future-today
>>> print(delta)
10951 days, 22:28:00
    

Добавление найденной разности к первой дате «возвращает» нас в «будущее»:

        >>> print(today + delta)
2015-10-21 19:28:00
    

Узнаем, какое число будет через четыре недели. Для форматирования строк в модуле datetime имеется функция strftime() с теми же спецификаторами, что и в модуле time:

        >>> today = datetime.datetime.now()
>>> future = today + datetime.timedelta(days=28)
>>> f = '%d.%m.%y'
>>> print(today.strftime('Сегодня: ' + f))
Сегодня: 30.11.19
>>> print(future.strftime('Через 28 дней будет: ' + f))
Через 28 дней будет: 28.12.19
    

Если вам важнее оперировать не датами, а неделями, днями недели, месяцами, годами, то вам нужен модуль calendar.

Модуль calendar содержит функции для работы с календарем. В частности, умеет генерировать строки и HTML для вывода каленадарей месяцев и годов. Для наглядности напечатаем календарь на декабрь 2019 года:

        >>> calendar.prmonth(2019, 12)
    декабря 2019
Пн Вт Ср Чт Пт Сб Вс
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
    

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

        # пустая строка в списке соответствует нулевому месяцу, первый месяц - январь
>>> month_names = ['', 'январь', 'февраль', 'март', 'апрель', 'май', 'июнь',
'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь']
>>> calendar.month_name = month_names
>>> calendar.prmonth(2019, 12)
    декабрь 2019
Пн Вт Ср Чт Пт Сб Вс
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
    

Или использовать сокращения:

        >>> calendar.month_name = calendar.month_abbr
>>> calendar.prmonth(1985, 10)
      окт 1985
Пн Вт Ср Чт Пт Сб Вс
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31
    

При помощи calendar можно не только «рисовать» календари, но и осуществлять итерации по их составляющим.

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

        free_days = []

for i in range(1, 13):
    c = calendar.monthcalendar(2020, i)
    first_week = c[0]
    third_week = c[2]
    fourth_week = c[3]

    # Если на первой неделе месяца есть четверг, то третий
    # четверг должен быть на третьей неделе. Если нет, то
    # на четвертой
    if first_week[calendar.THURSDAY]:
        free_day = third_week[calendar.THURSDAY]
    else:
        free_day = fourth_week[calendar.THURSDAY]
    s = '{0} {1}'.format(free_day, calendar.month_name[i])
    free_days.append(s)

print(", ".join(free_days))
    

        16 янв, 20 фев, 19 мар, 16 апр, 21 мая, 18 июн, 16 июл, 20 авг, 17 сен, 15 окт, 19 ноя, 17 дек
    

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

• dateutil – расширение стандартного модуля datetime для более специфичных операций, например, парсинга дат и их составляющих
• pytz – для сложных манипуляций с часовыми поясами и летним временем
• delorean – библиотека, названная в честь машины времени из фильма «Назад в будущее», упрощающая работу с датами
• arrow – библиотека, стремящаяся заменить собой все вышеперечисленные, объединив их лучшие качества и заполнив пробелы
• astropy – выполнение астрономических расчётов
• tqdm – создание текстовых и интерактивных виджетов, отображающих процент выполнения длительного процесса (в том числе в Jupyter)

Знаете другие библиотеки для управления временем в Python? Расскажите о них 😉

решение задач на основе даты, месяца и года

От автора: модуль календаря в Python содержит класс календаря, который позволяет выполнять вычисления для различных задач на основе даты, месяца и года. Кроме того, классы Python TextCalendar и HTMLCalendar позволяют редактировать календарь и использовать его в соответствии с вашими потребностями.

Давайте рассмотрим, что мы можем сделать с Python Calendar.

Шаг 1) Запустите код.

Строка кода 1: Мы начинаем с «import calendar», который импортирует все классы этого модуля.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Строка кода 3: c = calendar.TextCalendar (calendar.SUNDAY) указывает интерпретатору создать текстовый календарь. Начало месяца будет воскресенье. В Python вы можете отформатировать календарь, так как вы можете изменить день, с которого начинать месяц.

Строка кода 4: str = c.formatmonth (2025,1) создает календарь на 2025 год, месяц 1 — январь

Строка кода 5: print str выводит результат.

Давайте изменим значение с воскресенья на четверг и проверим вывод.

Шаг 2) Вы также можете вывести Календарь в формате HTML, эта функция полезна для разработчиков, если они хотят внести какие-либо изменения во внешний вид календаря.

Шаг 3) Перебираем через цикл дни месяца с помощью c.itermonthday(2025,4), мы получим общее количество дней в этом месяце.

Когда вы выполните код, чтобы получить общее количество дней для определенного месяца, скажем, апреля, вы получите 30 дней, но вы также увидите несколько нулей вместе с этими днями в начале, а иногда и в конце.

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

Эти нули появляются в выводе, потому что в коде вы указали день (четверг), поэтому при вызове функции «c.itermonthdays» она начнет отсчет дней с четверга, и четверг может приходиться не на 1апреля, а на 28 или 29 марта, так что при выполнении кода она начнет отсчет дней с 28 марта. Дни с 28 марта до 1 апреля будут засчитываться как ноль, и в выходных данных вы увидите эти нули, и то же самое применимо к концу месяца.

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

Шаг 4) Вы можете получить данные из локальной системы, например, месяцы или дни недели и т. д.

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

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

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

Шаг 5) Вы можете получить список для определенного дня недели на целый год. Например, каждый первый понедельник недели. Если вы хотите знать дату первого понедельника для каждого месяца, вы можете использовать этот код.

mycal = calendar.monthcalendar (2025, месяц) создаст календарь на месяц

Устанавливаем переменные week1 и week2 для первой и второй недели календаря

Проверяем, содержит ли неделя 1 понедельник, устанавливаем контрольный день

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

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

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

Здесь мы используем постоянную календаря Monday, объект календаря предоставляет константы, которые представляют Sunday, Monday, Tuesday и так далее. Мы рассмотрели это ранее. Итак, если на первой неделе день, представленный константой Monday, не равен 0, он принадлежит этому месяцу. Если он равен нулю, это будет понедельник, который относится к предыдущему месяцу. Но если первый понедельник не равен 0, это означает, что контрольный день будет в первой неделе. Иначе, если это 0, тогда первый понедельник не в первой неделе месяца, он должен быть во второй.

Контрольный день будет возвращен с тем, какой на какой неделе он будет.

Вот полный код

Пример Python 2

import calendar
# Создаем обычный текстовый календарь
c = calendar.TextCalendar(calendar.THURSDAY)
str = c.formatmonth(2025, 1, 0, 0)
print str

# Создаем календарь в формате HTML
hc = calendar.HTMLCalendar(calendar.THURSDAY)
str = hc.formatmonth(2025, 1)
print str
# перебираем через цикл дни месяца
# нули указывают, что дни принадлежат смежному месяцу
for i in c.itermonthdays(2025, 4):
print i

# Календарь может выдавать информацию на основе локальных настроек, таких как название дней и месяцев (полных или сокращенных)
for name in calendar.month_name:
print name
for day in calendar.day_name:
print day
# вычисляем день на основе правил: Например для каждого второго понедельника каждого месяца
# Устанавливаем это для каждого месяца, мы можем использовать следующий скрипт
for month in range(1, 13):
# Он извлекает список недель, который представляет месяц
mycal = calendar.monthcalendar(2025, month)
# Первый MONDAY должен принадлежать первой или второй неделе
week1 = mycal[1]
week2 = mycal[2]
if week1[calendar.MONDAY] != 0:
auditday = week1[calendar.MONDAY]
else:
# если первый MONDAY не принадлежит первой неделе, он должен быть на второй неделе
auditday = week2[calendar.MONDAY]
print «%10s %2d» % (calendar.month_name[month], auditday)

Пример Python 3

import calendar
# Создаем обычный текстовый календарь
c = calendar.TextCalendar(calendar.THURSDAY)
str = c.formatmonth(2025, 1, 0, 0)
print(str)

# Создаем календарь в формате HTML
hc = calendar.HTMLCalendar(calendar.THURSDAY)
str = hc.formatmonth(2025, 1)
print(str)
# перебираем через цикл дни месяца
# нули указывают, что дни принадлежат смежному месяцу
for i in c.itermonthdays(2025, 4):
print(i)

# Календарь может выдавать информацию на основе локальных настроек, таких как название дней и месяцев (полных или сокращенных)
for name in calendar.month_name:
print(name)
for day in calendar.day_name:
print(day)
# вычисляем день на основе правил: Например для каждого второго понедельника каждого месяца
# Устанавливаем это для каждого месяца, мы можем использовать следующий скрипт
for month in range(1, 13):
# Он извлекает список недель, который представляет месяц
mycal = calendar.monthcalendar(2025, month)
# Первый MONDAY должен принадлежать первой или второй неделе
week1 = mycal[1]
week2 = mycal[2]
if week1[calendar.MONDAY] != 0:
auditday = week1[calendar.MONDAY]
else:
# если первый MONDAY не принадлежит первой неделе, он должен быть на второй неделе
auditday = week2[calendar.MONDAY]
print(«%10s %2d» % (calendar.month_name[month], auditday))

Резюме:

В Python вы можете отформатировать календарь так, как хотите, вы можете изменить начальный день месяца

Вывести календарь в формате HTML

Получить данные из локальной системы, например, месяцы или дни недели

Получить список определенного дня недели на целый год

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Глава 22 — Работа с датой и временем — документация Python 101 1.0

Python предоставляет разработчику несколько инструментов для работы с датой и временем. В этой главе мы рассмотрим модули datetime и time . Мы изучим, как они работают, и некоторые общие способы их использования. Начнем с модуля datetime !

Модуль datetime

Из модуля datetime мы узнаем о следующих классах:

• дата и время.дата
• datetime.timedelta
• datetime.datetime

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

datetime.date

Python может представлять даты несколькими способами. Мы собираемся взглянуть на дату и время .date , так как это один из самых простых объектов даты.

 >>> datetime.date (2012, 13, 14)
Отслеживание (последний вызов последний):
  Файл "<строка>", строка 1, в <фрагменте>
builtins.ValueError: месяц должен быть в 1..12
>>> datetime.date (2012, 12, 14)
datetime.date (2012, 12, 14)
 

Этот код показывает, как создать простой объект даты. Класс даты принимает три аргумента: год, месяц и день. Если вы передадите ему недопустимое значение, вы увидите ValueError , как показано выше.В противном случае вы увидите возвращенный объект datetime.date . Давайте посмотрим на другой пример:

 >>> импорт datetime
>>> d = datetime.date (2012, 12, 14)
>>> д.год
2012 г.
>>> день
14
>>> d.month
12
 

Здесь мы присваиваем объект даты переменной d . Теперь мы можем получить доступ к различным компонентам даты по имени, например, d.year или d.month . А теперь давайте узнаем, какой сегодня день:

.

 >>> дата и время.date.today ()
datetime.date (2014, 3, 5)
 

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

datetime.datetime

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

 >>> datetime.datetime (2014, 3, 5)
datetime.datetime (2014, 3, 5, 0, 0)
>>> datetime.datetime (2014, 3, 5, 12, 30, 10)
datetime.datetime (2014, 3, 5, 12, 30, 10)
>>> d = datetime.datetime (2014, 3, 5, 12, 30, 10)
>>> д.год
2014 г.
>>> d.second
10
>>> d.hour
12
 

Здесь мы видим, что datetime.datetime принимает несколько дополнительных аргументов: год, месяц, день, час, минута и секунда. Он также позволяет указать информацию о микросекундах и часовом поясе.Когда вы работаете с базами данных, вы часто будете использовать эти типы объектов. В большинстве случаев вам потребуется преобразовать формат даты или даты и времени Python в формат даты и времени или метки времени SQL. Вы можете узнать, что сегодня происходит с datetime.datetime, используя два разных метода:

 >>> datetime.datetime.today ()
datetime.datetime (2014, 3, 5, 17, 56, 10, 737000)
>>> datetime.datetime.now ()
datetime.datetime (2014, 3, 5, 17, 56, 15, 418000)
 

В модуле datetime есть еще один метод, о котором вы должны знать, — strftime .Этот метод позволяет разработчику создать строку, представляющую время в более удобочитаемом формате. Есть целая таблица параметров форматирования, которую вам следует прочитать в документации Python, раздел 8.1.7. Мы рассмотрим несколько примеров, чтобы показать вам возможности этого метода:

 >>> datetime.datetime.today (). Strftime ("% Y% m% d")
'20140305'
>>> сегодня = datetime.datetime.today ()
>>> today.strftime ("% m /% d /% Y")
'03 / 05/2014 '
>>> сегодня.strftime ("% Y-% m-% d-% H.% M.% S")
'2014-03-05-17.59.53'
 

Первый пример — это своего рода взлом. Он показывает, как преобразовать сегодняшний объект datetime в строку, соответствующую формату ГГГГММДД (год, месяц, день). Второй пример лучше. Здесь мы назначаем сегодняшний объект datetime переменной с именем today , а затем пробуем две разные операции форматирования строк. Первый добавляет косую черту между элементами datetime, а также меняет его порядок, чтобы он стал месяцем, днем, годом.В последнем примере создается своего рода метка времени в довольно типичном формате: ГГГГ-ММ-ДД.ЧЧ.ММ.СС. Если вы хотите перейти к двузначному году, вы можете заменить % и на % и .

datetime.timedelta

Объект datetime.timedelta представляет продолжительность времени. Другими словами, это разница между двумя датами или временем. Давайте посмотрим на простой пример:

 >>> сейчас = datetime.datetime.now ()
>>> сейчас
дата и время.datetime (2014, 3, 5, 18, 13, 51, 230000)
>>> затем = datetime.datetime (2014, 2, 26)
>>> delta = сейчас - потом
>>> тип (дельта)
<тип 'datetime.timedelta'>
>>> delta.days
7
>>> delta.seconds
65631
 

Здесь мы создаем два объекта datetime. Один на сегодня и один неделю назад. Затем мы берем разницу между ними. Это возвращает объект timedelta, который мы можем затем использовать, чтобы узнать количество дней или секунд между двумя датами. Если вам нужно знать количество часов или минут между ними, вам придется использовать математику, чтобы это вычислить.Вот один из способов сделать это:

 >>> секунд = delta.total_seconds ()
>>> часы = секунды // 3600
>>> часы
186,0
>>> минут = (секунд% 3600) // 60
>>> минут
13,0
 

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

Теперь мы готовы двигаться дальше и немного узнать о модуле time !

Модуль времени

Модуль time предоставляет разработчику Python доступ к различным функциям, связанным со временем.Модуль времени основан на так называемой эпохе , точке начала времени. Для систем Unix эпохой был 1970 год. Чтобы узнать, какая эпоха находится в вашей системе, попробуйте запустить следующее:

 >>> время импорта
>>> time.gmtime (0)
time.struct_time (tm_year = 1970, tm_mon = 1, tm_mday = 1, tm_hour = 0, tm_min = 0,
                 tm_sec = 0, tm_wday = 3, tm_yday = 1, tm_isdst = 0)
 

Я запускал это в Windows 7, и мне тоже кажется, что время началось в 1970 году.В любом случае, в этом разделе мы будем изучать следующие функции, связанные со временем:

• time.ctime
• время сна
• time.strftime
• время. Время

Приступим!

time.ctime

Функция time.ctime преобразует время в секундах, прошедшее с начала эпохи, в строку, представляющую местное время. Если ничего не передать, то возвращается текущее время. Давайте попробуем пару примеров:

 >>> время импорта
>>> время.ctime ()
'Чт, 06 марта, 07:28:48 2014'
>>> time.ctime (1384112639)
'Вс, 10 ноя, 13:43:59 2013'
 

Здесь мы показываем результаты вызова ctime вообще ни с чем и с довольно случайным количеством секунд с начала эпохи. Я видел что-то, что использовалось, когда кто-то сохранял дату в секундах с эпохи, а затем они хотели преобразовать ее во что-то, что может понять человек. Немного проще сохранить большое целое число (или длинное число) в базе данных, чем возиться с его форматированием из объекта datetime в любой объект даты, который принимает база данных.Конечно, у этого также есть недостаток, заключающийся в том, что вам нужно преобразовать целочисленное значение или значение с плавающей запятой обратно в строку.

время сна

Функция time.sleep дает разработчику возможность приостановить выполнение вашего скрипта на заданное количество секунд. Это все равно, что добавить паузу в вашу программу. Я нашел это лично полезным, когда мне нужно подождать секунду, пока файл завершит закрытие или фиксация базы данных завершится. Давайте посмотрим на пример. Откройте новое окно в IDLE и сохраните следующий код:

 импортное время

для x в диапазоне (5):
    время.сон (2)
    print («Спал 2 секунды»)
 

Теперь запустите код в IDLE. Вы можете сделать это, перейдя в меню Run и затем выбрав пункт меню Run module . Когда вы это сделаете, вы увидите, что он распечатывает фразу Slept for 2 секунды пять раз с двухсекундной паузой между каждой печатью. Это действительно так просто!

time.strftime

Модуль time имеет функцию strftime , которая работает почти так же, как версия datetime.Разница в основном заключается в том, что он принимает для ввода: кортеж или объект struct_time , как те, которые возвращаются при вызове time.gmtime () или time.localtime () . Вот небольшой пример:

 >>> time.strftime ("% Y-% m-% d-% H.% M.% S",
                  time.localtime ())
'2014-03-06-20.35.56'
 

Этот код очень похож на код временной метки, который мы создали в части, посвященной дате и времени в этой главе. Я думаю, что метод datetime немного более интуитивно понятен, поскольку вы просто создаете дату и время .datetime , а затем вызовите его метод strftime в желаемом формате. С модулем времени вы должны передать формат плюс кортеж времени. Вам действительно решать, какой из них наиболее подходит для вас.

время. Время

Функция time.time вернет время в секундах с начала эпохи в виде числа с плавающей запятой. Давайте посмотрим:

 >>> time.time ()
1394199262,318
 

Это было довольно просто.Вы можете использовать это, если хотите сохранить текущее время в базе данных, но не хотите беспокоиться о преобразовании его в метод datetime базы данных. Вы также можете вспомнить, что метод ctime принимает время в секундах, поэтому мы могли бы использовать time.time , чтобы получить количество секунд для передачи ctime, например:

 >>> время.ctime (время.время ())
'Пт, 07 мар, 07:36:38 2014'
 

Если вы немного покопаетесь в документации для модуля времени или просто немного поэкспериментируете с ним, вы, вероятно, найдете несколько других применений этой функции.

Завершение

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

.

Страница не найдена · GitHub Pages

Страница не найдена · GitHub Pages

Файл не найден

Сайт, настроенный по этому адресу, не
содержать запрошенный файл.

Если это ваш сайт, убедитесь, что регистр имени файла соответствует URL-адресу.
Для корневых URL (например, http://example.com/ ) вы должны предоставить
index.html файл.

Прочтите полную документацию
для получения дополнительной информации об использовании GitHub Pages .

.

8.1. datetime — Основные типы даты и времени — документация Python 3.3.7

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

Есть два типа объектов даты и времени: «наивные» и «осведомленные».

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

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

Для приложений, требующих осведомленных объектов, даты, времени и времени
объекты имеют необязательный атрибут информации о часовом поясе, tzinfo, который
может быть установлен как экземпляр подкласса абстрактного класса tzinfo.
Эти объекты tzinfo собирают информацию о смещении от UTC.
время, название часового пояса и то, действует ли летнее время. Запись
что только один конкретный класс tzinfo, класс часового пояса,
предоставляется модулем datetime.Класс часового пояса может
представляют собой простые часовые пояса с фиксированным смещением от UTC, например сам UTC или
Часовые пояса Северной Америки EST и EDT. Поддержка часовых поясов на более глубоких уровнях
детали до приложения. Правила корректировки времени по
мир больше политический, чем рациональный, часто меняется, и нет
стандарт подходит для всех приложений, кроме UTC.

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

datetime.MINYEAR

Наименьшее допустимое число года в

.

datetime — Создание диапазона дат в Python

Переполнение стека

1. Около

2. Продукты

3. Для команд

1. Переполнение стека
   Общественные вопросы и ответы

2. Переполнение стека для команд
   Где разработчики и технологи делятся частными знаниями с коллегами

3. Вакансии
   Программирование и связанные с ним технические возможности карьерного роста

4. Талант
   Нанимайте технических специалистов и создавайте свой бренд работодателя

5. Реклама
   Обратитесь к разработчикам и технологам со всего мира

6. О компании

.