Python 3 time: datetime — Basic date and time types — Python 3.11.2 documentation

datetime ⚡️ Python 3 с примерами кода

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

Класс datetime.date(year, month, day) — стандартная дата. Атрибуты: year, month, day. Неизменяемый объект.

Класс datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None) — стандартное время, не зависит от даты. Атрибуты: hour, minute, second, microsecond, tzinfo.

Класс datetime.timedelta — разница между двумя моментами времени, с точностью до микросекунд.

Класс datetime.tzinfo — абстрактный базовый класс для информации о временной зоне (например, для учета часового пояса и / или летнего времени).

Класс datetime.

Обязательные аргументы:

• datetime.MINYEAR (1) ≤ year ≤ datetime.MAXYEAR (9999)
• 1 ≤ month ≤ 12
• 1 ≤ day ≤ количество дней в данном месяце и году

Необязательные:

• 0 ≤ minute < 60
• 0 ≤ second < 60
• 0 ≤ microsecond < 1000000

Методы класса datetime:

datetime.today()

объект datetime из текущей даты и времени. Работает также, как и datetime.now() со значением

tz=None.

datetime.fromtimestamp(timestamp)

дата из стандартного представления времени.

datetime.fromordinal(ordinal)

дата из числа, представляющего собой количество дней, прошедших с 01.01.1970.

datetime.now(tz=None)

объект datetime из текущей даты и времени.

datetime.combine(date, time)

объект datetime из комбинации объектов date и time.

datetime.strptime(date_string, format)

преобразует строку в datetime (так же, как и функция strptime из модуля time).

datetime.strftime(format)

см. функцию strftime из модуля time.

datetime.date()

объект даты (с отсечением времени).

datetime.time()

объект времени (с отсечением даты).

datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])

возвращает новый объект datetime с изменёнными атрибутами.

datetime.timetuple()

возвращает struct_time из datetime .

datetime.toordinal()

количество дней, прошедших с 01.01.1970.

datetime.timestamp()

возвращает время в секундах с начала эпохи.

datetime.weekday()

день недели в виде числа, понедельник — 0, воскресенье — 6.

datetime.isoweekday()

день недели в виде числа, понедельник — 1, воскресенье — 7.

datetime.isocalendar()

кортеж (год в формате ISO, ISO номер недели, ISO день недели).

datetime.isoformat(sep='T')

красивая строка вида YYYY-MM-DDTHH:MM:SS.mmmmmm или, если microsecond == 0, YYYY-MM-DDTHH:MM:SS

datetime.ctime()

см. ctime() из модуля time.

Пример работы с классом datetime:

>>> from datetime import datetime, date, time
>>> # Using datetime. combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now() or datetime.utcnow()
>>> datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.utcnow()
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:
...     print(it)
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:
.
   ..     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday
>>> # Formatting datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'

Даты, время и календари в Python: 3 основных модуля

Изменение цен на нефть со временем, изменение температуры за день, уровень цен за месяц, доходы за год — все эти компоненты объединяет время. В Data Science часто приходится сталкиваться с временными рядами. Сегодня мы расскажем о стандартных модулях Python, которые предоставляют интерфейс для дат и времени: time, datetime, calendar.

3 основных модуля

В комплекте стандартных библиотек Python имеются три основных модуля для работы со временем, датами и календарем:

1. time предоставляет различные функции для управления значениями времени;
2. datetime поможет для работы с датами;
3. calendar обеспечит идеализированным григорианским календарем.

Далее мы рассмотрим, как их можно использовать в реальных проектах Data Science и повседневных задачах Python-программиста.

Модуль time для отсчета времени

Время в Python отсчитывается в секундах от начала эпохи. Эпоха может отличаться для разных операционных систем. Для Unix-систем эпоха — это январь 1970 года 00:00:00. Чтобы узнать, какая эпоха на компьютере, используется функция time.gmtime(0)

>>> import time
>>> 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)

Возвращается объект time_struct, который имеет атрибуты в виде года, месяца, недели и т.д. Последний атрибут tm_isdst показывает летнее ли время (0 — нет, 1- да).

Считаем время в Python

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

>>> time.time()
1598423943.4023273

Можно получить объект time_struct с нынешним временем в вашем часовом поясе, для этого есть

>>> time. localtime()
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=26, tm_hour=13, tm_min=39, tm_sec=43, tm_wday=2, tm_yday=239, tm_isdst=0)

Получить полный форматированный вариант в читаемом виде поможет функция time.asctime():

>>> time.asctime()
'Wed Aug 26 13:51:33 2020'

Более удобный формат времени

Функция asctime возвращает полную информацию о времени в определенном формате. Когда требуется самостоятельно задать формат вывода, в Python можно воспользоваться функцией

>>> time.strftime("%a %d %Y", time.localtime())
'Wed 26 2020'

Здесь %a означает день недели, %d — день месяца, а %Y — год. Полный список доступен в официальной документации.

Из строки в time_stuct

А вот получить из строки (str) соответствующий объект time_struct можно с помощью функции strptime:

>>> time.
  strptime("Wed 26 2020", "%a %d %Y")

time.struct_time(tm_year=2020, tm_mon=1, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=26, tm_isdst=-1)

Не стоит путать с strftime, так как они различаются на одну букву.

Засыпаем на некоторое время

Иногда требуется сымитировать действие, которое занимает определенное время. На помощь придет функция sleep, которая аргументом принимает секунды:

>>> def timeit(secs):
...     start = time.time()
...     time.sleep(secs) # заснуть на secs
...     end = time.time(

...     return end - start
...
>>> timeit(1)
1.0011100769042969

Работаем с датами

Интерфейс для дат в Python можно найти в модуле datetime. У него есть 3 основных класса: date, time и datetime — для работы с только датами, только временем и с датой и временем, соответственно. Объект date принимает в качестве аргументов год, месяц и день:

>>> from datetime import date, time, datetime
>>> date(year=2020, month=1, day=15)
datetime.date(2020, 1, 15)

Объект time принимает часы, минуты и секунды:

>>> time(hour=18, minute=45, second=30)
datetime.time(18, 45, 30)

Объект datetime принимает все вышеперечисленное:

>>> datetime(year=2020, month=1, day=15, hour=18, minute=45, second=30)
datetime.datetime(2020, 1, 15, 18, 45, 30)

Сейчас и сегодня

В Python можно получить сегодняшнюю дату:

>>> date.today()
datetime.date(2020, 8, 26)

А также, текущую дату и время:

>>> datetime.today()
datetime.datetime(2020, 8, 26, 15, 52, 39, 757438)

Получаем даты из ISO-формата

Помимо прочего, можно получить дату из ISO формат с видом YYYY-MM-DD:

>>> date. fromisoformat("2020-01-15")
datetime.date(2020, 1, 15)

В Python 8 был добавлен метод fromisocalendar, который принимает в качестве аргументов год, неделю, месяц:

>>> date.fromisocalendar(2020, 45, 3)
datetime.date(2020, 11, 4)

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

Как и время из модуля time, объект datetime имеет методы strptime и strftime для получение строки из даты и наоборот:

>>> datetime.strptime("Wed 26 2020", "%a %d %Y")
datetime.datetime(2020, 1, 26, 0, 0)
>>> today = datetime.today()
>>> today.strftime("%a %d %Y")
'Wed 26 2020'

Из секунд в даты

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

>>> now = time. time()
>>> datetime.fromtimestamp(now) 
datetime.datetime(2020, 8, 26, 13, 39, 3, 402327)

Сколько времени прошло

В Python-модуле datetime имеется специальный объект timedelta, который используется для разницы между датами

>>> from datetime import timedelta
>>> timedelta(days=10, seconds=25)
datetime.timedelta(days=10, seconds=25)

Например, можно получить разницу между сегодняшним и вчерашним днями:

>>> today = datetime.today()
>>> yesterday = date(2020, 8, 25)
>>> today - yesterday
datetime.timedelta(days=1)

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

Работаем с календарем

В Python также можно работать с календарем, который есть в модуле calendar. Объект Calendar позволяет итерировать дни и недели в месяце, в году и т. д. Например, метод monthdatescalendar вернет список дней (объекты datetime) заданного месяца и года, причем дополнит их так, чтобы начинался с первого дня понедельника прошлого месяца и заканчивался последним воскресенья следующего (для августа 2020 — это 27 июля и 6 сентября):

>>> from calendar import Calendar
>>> c = Calendar()
>>> c.monthdatescalendar(2020, 8)
[datetime.date(2020, 7, 27),
datetime.date(2020, 7, 28),
...
datetime.date(2020, 8, 1),
datetime.date(2020, 8, 2),
...
datetime.date(2020, 8, 31),
...
datetime.date(2020, 9, 6)]

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

В Python 3.7 были добавлены методы, которые возвращают не список, а генератор (о них мы писали тут). Поэтому вместо monthdatescalendar можно использовать itermonthdays.

Печатаем календарь на месяц

В Python можно получить календарь в читаемом формате с помощью prmonth:

>>> import calendar
>>> calendar.prmonth(2020, 8)
    August 2020
Mo Tu We Th Fr Sa Su
                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

Печатаем календарь на год

А вот функция prcal напечатает весь календарь заданного года:

>>> calendar.prcal(2020)
      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
       1  2  3  4  5                      1  2                         1
 6  7  8  9 10 11 12       3  4  5  6  7  8  9       2  3  4  5  6  7  8
13 14 15 16 17 18 19      10 11 12 13 14 15 16       9 10 11 12 13 14 15
20 21 22 23 24 25 26      17 18 19 20 21 22 23      16 17 18 19 20 21 22
27 28 29 30 31            24 25 26 27 28 29         23 24 25 26 27 28 29
                                                    30 31
. ..остальные месяцы

Дни недели

Что не перечислять дни недели самостоятельно (Monday, Tuesday и т.д), можно использовать готовые перечисления. Также с функцией weekday можно узнать день недели заданного дня:

>>> calendar.WEDNESDAY
2
>>> calendar.weekday(2020, 8, 26)
2

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

Смотреть расписание

Записаться на курс

16.3. time — доступ ко времени и преобразования — документация по Python 3.6.3

Этот модуль предоставляет различные функции, связанные со временем. Для связанных см. также модули datetime и calendar .

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

Необходимо пояснение некоторых терминов и соглашений.

• Эпоха — точка начала времени и платформа зависимый. Для Unix эпоха — 1 января 1970 года, 00:00:00 (UTC). Чтобы узнать, какая эпоха на данной платформе, посмотрите на время.gmtime(0) .

• Термин секунд с эпохи относится к общему числу прошедших секунд с начала эпохи, обычно исключая високосные секунды. Високосные секунды исключаются из этого общего количества на всех POSIX-совместимые платформы.

• Функции в этом модуле могут не обрабатывать даты и время до эпохи или далеко в будущем. Точка отсечки в будущем определяется C библиотека; для 32-битных систем это обычно 2038.

• Проблемы 2000 года (Y2K) : Python зависит от библиотеки C платформы, которая обычно не имеет выпусков за 2000 год, так как все даты и время внутренне представлено в виде секунд с начала эпохи. Функция strptime() может анализировать 2-значные годы, если задан код формата %y . Когда двузначные годы анализируются, они преобразуются в соответствии со стандартами POSIX и ISO C: значения 69–99 сопоставлены с 1969–1999 гг., а значения 0–68 сопоставлены с 2000–2068 гг.

• UTC — всемирное координированное время (ранее известное как среднее время по Гринвичу, или ВРЕМЯ ПО ГРИНВИЧУ). Аббревиатура UTC — не ошибка, а компромисс между английским и Французский.

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

• Точность различных функций реального времени может быть меньше, чем предлагается единицы, в которых выражается их значение или аргумент. Например. на большинстве Unix систем часы «тикают» только 50 или 100 раз в секунду.

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

• Значение времени, возвращаемое gmtime() , localtime() , и strptime() и принимается asctime() , mktime() и strftime() — это последовательность из 9 целых чисел. Возвращаемые значения гмтайм() , местное время() и strptime() также предлагают атрибут имена для отдельных полей.

  См. struct_time для описания этих объектов.

  Изменено в версии 3.3: Тип struct_time был расширен для предоставления tm_gmtoff . и атрибутов tm_zone , если платформа поддерживает соответствующие структура тм членов.

  Изменено в версии 3.6: struct_time атрибуты tm_gmtoff и тм_зона теперь доступны на всех платформах.

• Используйте следующие функции для преобразования между представлениями времени:

  от эпохи эпохи

  Из	до	Использовать
  секунд с начала эпохи	struct_time в UTC	гмвремя()
  секунд с начала эпохи	struct_time в местное время	местное время()
  struct_time в UTC	секунд с	календарь. timegm()
  struct_time в местное время	секунд с	мктайм()

Модуль определяет следующие функции и элементы данных:

раз. альтзона

Смещение местного часового пояса летнего времени в секундах к западу от UTC, если оно определено. Это отрицательное значение, если местный часовой пояс DST находится восточнее UTC (как в Западной Европе, включая Великобританию). Используйте это только в том случае, если дневного света не равно нулю.

раз. asctime ([ t ])

Преобразовать кортеж или struct_time , представляющий время, возвращаемое gmtime() или localtime() в строку из следующего форма: 'Вс, 20 июня 23:21:05 1993' . Если t не указан, текущее время как возвращено localtime(), используется . Информация о локали не используется asctime() .

Примечание

В отличие от одноименной функции C, asctime() не добавляет завершающая новая строка.

раз. часы ()

В Unix возвращает текущее время процессора в виде числа с плавающей запятой, выраженного в секундах. Точность и, по сути, само определение смысла «процессорное время» зависит от одноименной функции C.

В Windows эта функция возвращает количество секунд настенных часов, прошедших с момента первого вызов этой функции в виде числа с плавающей запятой на основе функции Win32 QueryPerformanceCounter() . Разрешение обычно лучше одного микросекунда.

Устарело, начиная с версии 3.3: поведение этой функции зависит от платформы: используйте perf_counter() или process_time() вместо , в зависимости от вашего требования, чтобы иметь четко определенное поведение.

раз. часы_getres ( clk_id )

Возвращает разрешение (точность) указанных часов clk_id .

Доступность: Unix.

Новое в версии 3.3.

раз. часы_gettime ( clk_id )

Возвращает время указанных часов clk_id .

Доступность: Unix.

Новое в версии 3.3.

раз. clock_settime ( clk_id , время )

Установить время указанных часов clk_id .

Доступность: Unix.

Новое в версии 3.3.

раз. ЧАСЫ_ВЫСОКОЕ РАЗРЕШЕНИЕ

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

Наличие: Солярис.

Новое в версии 3.3.

раз. ЧАСЫ_МОНОТОНИК

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

Доступность: Unix.

Новое в версии 3.3.

раз. CLOCK_MONOTONIC_RAW

Аналогично CLOCK_MONOTONIC , но обеспечивает доступ к аппаратное время, которое не подлежит настройке NTP.

Доступность: Linux 2.6.28 или выше.

Новое в версии 3.3.

раз. CLOCK_PROCESS_CPUTIME_ID

Таймер высокого разрешения для каждого процесса от ЦП.

Доступность: Unix.

Новое в версии 3.3.

раз. ЧАСЫ_РЕАЛЬНОЕ ВРЕМЯ

Общесистемные часы реального времени. Установка этих часов требует соответствующего привилегии.

Доступность: Unix.

Новое в версии 3.3.

раз. CLOCK_THREAD_CPUTIME_ID

Часы времени процессора для конкретного потока.

Доступность: Unix.

Новое в версии 3.3.

раз. ctime ([ сек ])

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

раз. дневной свет

Ненулевое значение, если определен часовой пояс летнего времени.

раз. get_clock_info ( имя )

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

• 'часы' : время.часы()
• 'монотонный' : time.monotonic()
• 'perf_counter' : time.perf_counter()
• 'время_процесса' : время.время_процесса()
• 'время' : время.время()

Результат имеет следующие атрибуты:

• регулируемый : True , если часы могут быть изменены автоматически (например, демон NTP) или вручную системным администратором, False , иначе
• реализация : Имя базовой функции C, используемой для получения тактовое значение
• монотонный : Истинно , если часы не могут идти назад, Ложь иначе
• разрешение : Разрешение часов в секундах ( float )

Новое в версии 3. 3.

раз. гмвремя ([ сек ])

Преобразование времени, выраженного в секундах, начиная с эпохи, в struct_time в UTC, в котором флаг dst всегда равен нулю. Если секунд не указано или Нет , используется текущее время, возвращенное функцией time() . Фракции секунды игнорируются. См. выше описание struct_time объект. См. calendar.timegm() для инверсии этого функция.

раз. местное время ([ сек ])

Аналогично gmtime() , но преобразуется в местное время. Если секунд не указано или Нет , используется текущее время, возвращенное функцией time() . летнее время флаг устанавливается на 1 , когда летнее время применяется к данному времени.

раз. мктайм ( т )

Это обратная функция localtime() . Его аргументом является struct_time или полная 9-кортежность (поскольку требуется флаг dst; используйте -1 как флаг dst, если он неизвестен), который выражает время в местном времени , а не УНИВЕРСАЛЬНОЕ ГЛОБАЛЬНОЕ ВРЕМЯ. Он возвращает число с плавающей запятой для совместимости с time() . Если входное значение не может быть представлено как допустимое время, либо OverflowError или ValueError будет поднято (что зависит от будет ли недопустимое значение перехвачено Python или базовыми библиотеками C). Самая ранняя дата, для которой он может сгенерировать время, зависит от платформы.

раз. монотонный ()

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

В версиях Windows старше Vista monotonic() обнаруживает GetTickCount() целочисленное переполнение (32 бита, обновление через 49,7 дней). Увеличивает внутреннюю эпоху (отсчетное время) на 2 ³² каждый раз что обнаружено переполнение. Эпоха хранится в локальном состоянии процесса и поэтому значение monotonic() может отличаться в двух Python процессы, работающие более 49 дней. В более поздних версиях Windows и в других операционных системах monotonic() общесистемный.

Новое в версии 3.3.

Изменено в версии 3.5: Функция теперь всегда доступна.

раз. perf_counter ()

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

Новое в версии 3.3.

раз. процесс_время ()

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

Новое в версии 3.3.

раз. сон ( сек )

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

Изменено в версии 3.5: Теперь функция спит не менее секунд , даже если сон прерывается сигналом, за исключением случаев, когда обработчик сигнала вызывает исключение (см. PEP 475 для обоснования).

раз. strftime ( формат [ ​​ t ])

Преобразовать кортеж или struct_time , представляющий время, возвращаемое gmtime() или localtime() в строку, как указано в формат аргумент. Если t не указан, текущее время, возвращенное используется localtime() . формат должен быть строкой. ValueError есть поднимается, если какое-либо поле в t находится за пределами допустимого диапазона.

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

Следующие директивы могут быть встроены в строку формата . Они показаны без дополнительной ширины поля и спецификации точности и заменяются указанными символами в strftime() результат:

Директива	Значение	Примечания
%а	Сокращенное название дня недели региона.
%А	Полное название дня недели региона.
%b	Сокращенное название месяца в локали.
%В	Полное название месяца локали.
%с	Соответствующая дата и время локали представление.
%d	День месяца в виде десятичного числа [01,31].
%H	час (24-часовой формат) в виде десятичного числа [00,23].
%I	Hour (12-часовой формат) в виде десятичного числа [01,12].
%j	День года в виде десятичного числа [001,366].
%м	Месяц в виде десятичного числа [01,12].
%М	Минуты в виде десятичного числа [00,59].
%р	Локаль эквивалентна AM или PM.	(1)
%S	Секунда в виде десятичного числа [00,61].	(2)
%U	Номер недели года (воскресенье как первое день недели) в виде десятичного числа [00,53]. Все дни в новом году, предшествующие первому Воскресенье считается неделей 0.	(3)
% вес	День недели в виде десятичного числа [0(воскресенье),6].
%W	Номер недели года (понедельник как первый день недели) в виде десятичного числа [00,53]. Все дни в новом году, предшествующие первому Понедельник считается на неделе 0.	(3)
%х	Соответствующее представление даты Locale.
%Х	Соответствующее представление времени локали.
%г	Год без века в виде десятичного числа [00,99].
%Y	Год с веком в виде десятичного числа.
%z	Смещение часового пояса, указывающее положительное или отрицательная разница во времени с UTC/GMT форма +ЧЧММ или -ЧЧММ, где H представляет собой десятичное число цифры часа, а M представляет десятичную минуту цифры [-23:59, +23:59].
%Z	Название часового пояса (без символов, если нет часового пояса) существует).
%%	Литерал '%' символов.

Примечания:

1. При использовании с функцией strptime() директива %p влияет только на поле выходного часа, если для анализа часа используется директива %I .
2. Диапазон действительно равен 0 до 61 ; значение 60 действительно в временные метки, представляющие високосные секунды, и значение 61 поддерживаются по историческим причинам.
3. При использовании с функцией strptime() %U и %W используются только в вычисления, когда день недели и год указаны.

Вот пример, формат дат, совместимый с указанным в RFC 2822 Стандарт электронной почты в Интернете. [1]

 >>> из времени импортировать gmtime, strftime
>>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
«Чт, 28 июня 2001 г. , 14:17:15 +0000»
 

Дополнительные директивы могут поддерживаться на определенных платформах, но только перечисленные здесь имеют значение, стандартизированное ANSI C. Чтобы увидеть полный набор кодов форматов, поддерживаемых вашей платформой, см. в strftime(3) документация.

На некоторых платформах можно указать необязательную ширину поля и точность. сразу после начальной '%' директивы в следующем порядке; это тоже не переносимо. Ширина поля обычно равна 2, за исключением %j , где это 3.

раз. strptime ( строка [ ​​ формат ])

Разобрать строку, представляющую время, в соответствии с форматом. Возвращаемое значение является struct_time , возвращенным gmtime() или местное время() .

Формат 9Параметр 0016 использует те же директивы, что и strftime() ; по умолчанию он равен "%a %b %d %H:%M:%S %Y" , что соответствует форматирование, возвращаемое ctime() . Если строка не может быть проанализирована в соответствии с в формат , или если он имеет лишние данные после синтаксического анализа, ValueError поднятый. Значения по умолчанию, используемые для заполнения любых отсутствующих данных, когда больше точные значения не могут быть выведены: (1900, 1, 1, 0, 0, 0, 0, 1, -1) . Оба строка и формат должны быть строками.

Например:

 >>> время импорта
>>> time.strptime("30 ноября 00", "%d %b %y")
time.struct_time (tm_year = 2000, tm_mon = 11, tm_mday = 30, tm_hour = 0, tm_min = 0,
                 tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
 

Поддержка директивы %Z основана на значениях, содержащихся в tzname . и правда ли дневной свет . Из-за этого он зависит от платформы. за исключением признания UTC и GMT, которые всегда известны (и считаются быть часовыми поясами без перехода на летнее время).

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

класс время. время_структуры

Тип последовательности значений времени, возвращаемой гмвремя() , localtime() и strptime() . Это объект с именем Интерфейс кортежа: доступ к значениям можно получить по индексу и по имени атрибута. присутствуют следующие значения:

Индекс	Атрибут	Значения
0	тм_год	(например, 1993)
1	тм_мон	диапазон [1, 12]
2	тм_мдай	диапазон [1, 31]
3	тм_час	диапазон [0, 23]
4	тм_мин	диапазон [0, 59]
5	тм_сек	диапазон [0, 61]; см. (2) в strftime() описание
6	tm_wday	диапазон [0, 6], понедельник 0
7	tm_yday	диапазон [1, 366]
8	тм_исдст	0, 1 или -1; см. ниже
Н/Д	тм_зона	сокращение названия часового пояса
Н/Д	тм_гмтофф	смещение к востоку от UTC в секундах

Обратите внимание, что в отличие от структуры C, значение месяца представляет собой диапазон [1, 12], а не [0, 11].

При вызовах mktime() , tm_isdst может быть установлено в 1 при дневном свете действует экономия времени, и 0, когда это не так. Значение -1 указывает, что это неизвестно и обычно приводит к заполнению правильного состояния.

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

раз. время ()

Возвращает время в секундах с начала эпохи в виде числа с плавающей запятой число. Конкретная дата эпохи и обращение с високосные секунды зависят от платформы. В Windows и большинстве систем Unix это 1 января 1970 года. 00:00:00 (UTC) и високосные секунды не засчитываются во время в секундах с начала эпохи. Это обычно называют Время Юникс. Чтобы узнать, какая эпоха на данной платформе, посмотрите на гмвремя(0) .

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

Число, возвращаемое функцией time() , может быть преобразовано в более распространенное формат времени (т. е. год, месяц, день, час и т. д.) в формате UTC, передав его в gmtime() или по местному времени, передав его в функция локального времени() . В обоих случаях struct_time возвращается объект, из которого компоненты календарной даты могут быть доступны как атрибуты.

раз. часовой пояс

Смещение местного (не летнего) часового пояса в секундах к западу от UTC (отрицательное в большая часть Западной Европы, положительный результат в США, ноль в Великобритании).

раз. имя

Кортеж из двух строк: первая — это имя местного часового пояса, отличного от DST, во-вторых, это название местного часового пояса DST. Если часовой пояс DST не определен, вторую строку использовать не следует.

раз. цсет ()

Сбрасывает правила преобразования времени, используемые подпрограммами библиотеки. Окружающая среда переменная TZ указывает, как это делается.

Доступность: Unix.

Примечание

Хотя во многих случаях изменение переменной среды TZ может влияет на вывод функций, таких как localtime() , без вызова tzset() , на это поведение нельзя полагаться.

Переменная среды TZ не должна содержать пробелов.

Стандартный формат переменной среды TZ : (пробелы добавлено для ясности):

 стандартное смещение [dst [смещение [начало[/время], конец[/время]]]]
 

Где компоненты:

стандарт и стандарт

Три или более буквенно-цифровых символов, обозначающих часовой пояс. Это будет распространяется на time.tzname

смещение

Смещение имеет вид: ± чч[:мм[:сс]] . Это указывает на значение добавлено местное время для прибытия в UTC. Если перед ним стоит «-», часовой пояс находится к востоку от нулевого меридиана; в противном случае это запад. Если не следует смещение dst, предполагается, что летнее время на один час опережает стандартное время.

начало[/время], конец[/время]

Указывает, когда переходить на летнее время и обратно. Формат даты начала и окончания являются одним из следующих:

J n

Юлианский день n (1 <= n <= 365). Високосные дни не учитываются, поэтому в все годы 28 февраля — это 59-й день, а 1 марта — 60-й день.

нет

Отсчитываемый от нуля день по юлианскому календарю (0 <= н <= 365). Високосные дни считаются, и можно сослаться на 29 февраля.

М м . и . д

д ‘день (0 <= д <= 6) недели н месяца м года (1 <= n <= 5, 1 <= m <= 12, где неделя 5 означает «последние d дней в месяц м », что может произойти либо в четвертом, либо в пятом неделя). Неделя 1 — это первая неделя, в течение которой d -й день происходит. День ноль — воскресенье.

время имеет тот же формат, что и смещение , за исключением того, что без ведущего знака (‘-’ или ‘+’) допускается. По умолчанию, если время не указано, 02:00:00.

 >>> os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0'
>>> время.tzset()
>>> time.strftime('%X %x %Z')
'02:07:36 08.05.03 по восточному поясному времени'
>>> os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
>>> время.tzset()
>>> time.strftime('%X %x %Z')
'16:08:12 08.05.03 AEST'
 

Во многих системах Unix (включая *BSD, Linux, Solaris и Darwin) более удобно использовать системную базу данных zoneinfo ( tzfile(5) ) для указать правила часового пояса. Для этого установите среду TZ переменная на путь к требуемому файлу данных часового пояса относительно корня системная база данных часовых поясов «zoneinfo», обычно расположенная по адресу /usr/доля/zoneinfo . Например, "США/Восток" , 'Австралия/Мельбурн' , «Египет» или «Европа/Амстердам» .

 >>> os.environ['TZ'] = 'США/Восток'
>>> время.tzset()
>>> время.tzname
(«EST», «EDT»)
>>> os.environ['TZ'] = 'Египет'
>>> время.tzset()
>>> время.tzname
(«ЕЕТ», «ВОСТОЧНОЕ»)
 

См. также

Модуль datetime

Более объектно-ориентированный интерфейс для дат и времени.

Модуль языковой стандарт

Услуги интернационализации. Настройка локали влияет на интерпретацию многих спецификаторов формата в strftime() и strptime() .

Модуль Календарь

Общие функции, связанные с календарем. timegm() — это инверсия gmtime() из этого модуля.

Сноски

[1]

Использование %Z теперь не рекомендуется, но %z расширяется до escape-последовательности предпочтительное смещение час/минута поддерживается не всеми библиотеками ANSI C. Также строгое прочтение оригинала 1982 RFC 822 стандартные вызовы для двузначного год (%y, а не %Y), но практика перешла на 4-значные годы задолго до 2000 год. После этого RFC 822 устарел, а 4-значный год стал сначала было рекомендовано RFC 1123 , а затем предписано RFC 2822 .

Создание таймера в Python: пошаговое руководство

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

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

Общие сведения о таймерах в Python

Таймер в Python — это программа для отслеживания времени. Разработчики Python могут создавать таймеры с помощью модулей времени Python. Существует два основных типа таймеров: таймеры с прямым отсчетом и таймеры с обратным отсчетом.

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

Модуль , как time.time() . Первое время ссылается на модуль, а второе — на саму функцию. Функция time() возвращает количество секунд, прошедших с начала эпохи.

В вычислительном контексте мы называем «эпохой» время, в соответствии с которым компьютер вычисляет свои временные метки. Windows и большинство устройств UNIX устанавливают эпоху как 1 января 19.70 в 00:00:00.

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

время импорта
секунды = время.время()
print("Время в секундах с начала эпохи:", секунды)
local_time = время.ctime (секунды)
print("Местное время:", local_time)
 

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

Время в секундах с начала эпохи: 1630593076.1314547
Местное время: Чт 2 сен 10:31:16 2021
 

С начала эпохи прошло более 1,5 миллиардов секунд.

Функция time.sleep()

Другая функция, которая нам понадобится для построения нашего таймера, это time.sleep() . Эта функция создает задержку в программе, которую мы можем использовать для подсчета времени. time.sleep() принимает аргумент с плавающей запятой, представляющий количество секунд, на которые программа будет приостанавливаться. Подключите приведенный ниже пример к интегрированной среде разработки Python (IDE), чтобы увидеть, как работает time.delay() :

время импорта
print("Это начало программы.")
время сна(5)
print("Это печатается через пять секунд. ")
 

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

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

Функция datetime.timedelta()

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

импорт даты и времени
текущий = дата-время.дата-время.сейчас()
print("Текущая дата:", ул(текущая))
one_year = текущий + datetime.timedelta (дни = 365)
print("Дата в году:", str(one_year))
 

timedelta() добавляет 365 дней к текущей дате и выводит дату и время через год с точностью до микросекунды:

Текущая дата: 2021-09-02 14:44:19. 429447
Дата в одном году: 2022-09-02 14:44:19.429447
 

Простой таймер круга (секундомер)

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

время импорта
 
# Запускается таймер
время начала = время.время()
последний раз = время начала
лапнум = 1
значение = ""
 
print("Нажимайте ENTER для каждого круга.\nВведите Q и нажмите ENTER, чтобы остановиться.")
 
в то время как value.lower() != "q":
             
    # Ввод для нажатия клавиши ENTER
    значение = ввод ()
 
    # Текущее время круга
    время круга = раунд((время.время() - последний раз), 2)
 
    # Общее время, прошедшее с момента запуска таймера
    totaltime = round((time.time() - время начала), 2)
 
    # Печать номера круга, времени круга и общего времени
    print("Номер круга" +str(номер круга))
    print("Общее время: "+str(общее время))
    print("Время круга: "+str(время круга))
           
    печать("*"*20)
 
    # Обновление предыдущего общего времени и номера круга
    последний раз = время. время()
    лапнум += 1
 
print("Упражнение завершено!")
 

После импорта модуля time мы устанавливаем time.time() на время запуска нашего таймера. С этого момента секундомер начнет обратный отсчет. Мы используем переменную lasttime для каталогизации каждого круга, тогда как totaltime хранит значение на протяжении всего времени работы секундомера. lapnum подсчитывает количество пройденных нами кругов. Наконец, мы устанавливаем переменную со значением , чтобы пользователь мог ввести «Q» или «q», чтобы завершить программу.

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

Простой таймер обратного отсчета

Теперь построим таймер обратного отсчета. Этот пример включает в себя модуль datetime и функцию time.sleep() . Взгляните на программу ниже:

время импорта
импорт даты и времени
# Создайте класс, который действует как обратный отсчет
обратный отсчет (ч, м, с):
    # Подсчитать общее количество секунд
    total_seconds = ч * 3600 + м * 60 + с
    # Цикл while, который проверяет, достигает ли значение total_seconds нуля
    # Если не ноль, уменьшить общее время на одну секунду
    в то время как total_seconds > 0:
        # Таймер показывает время, оставшееся до окончания обратного отсчета
        таймер = datetime.timedelta (секунды = общее количество секунд)
       
        # Печатает оставшееся время на таймере
        печать (таймер, конец = "\ г")
        # Задерживает программу на одну секунду
        время сна(1)
        # Уменьшает общее время на одну секунду
        общее_секунды -= 1
    print("Бззз! Обратный отсчет равен нулю секунд!")
# Ввод часов, минут, секунд по таймеру
h = input("Введите время в часах:")
m = input("Введите время в минутах:")
s = input("Введите время в секундах:")
обратный отсчет (целое (ч), целое (м), целое (с))
 

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

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

Программа печатает оставшееся время в формате часы:минуты:секунды для просмотра пользователем. Сразу после этого программа делает паузу на одну секунду, уменьшает total_seconds на одну секунду и повторяет цикл while. Цикл продолжается до тех пор, пока total_seconds не достигнет нуля, после чего программа выходит из цикла while и печатает «Бзззз! Обратный отсчет равен нулю секунд!»

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

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

Давайте сравним несколько решений для поиска элемента в списке. Мы создадим список из 10 000 000 элементов и посмотрим, сколько времени потребуется каждому решению, чтобы найти число 700 000.

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

v​​время импорта
импортировать случайный
наш_список = список (диапазон (10000000))
элемент = 7000000
начало = время.время()
random_choice = random.choice(наш_список)
в то время как элемент random_choice !=:
    random_choice = random.choice(наш_список)
конец = время.время()
печать (конец - начало)
 

16.425415754318237
 

Программа нашла элемент за 16 секунд; это явно не к добру.

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

время импорта
наш_список = список (диапазон (10000000))
элемент = 7000000
начало = время. время()
для эл в нашем_списке:
    если эль == элемент:
        перерыв
конец = время.время()
печать (конец - начало)
 

0,60677099227
 

Эта программа заняла всего 0,6 секунды. Это намного лучше.

Давайте посмотрим, сможем ли мы победить на этот раз с помощью более сложного алгоритма под названием «двоичный поиск». Мы заимствуем код алгоритма с этой страницы GitHub.

время импорта
наш_список = список (диапазон (10000000))
элемент = 700000
начало = время.время()
двоичный_поиск (наш_список, элемент)
конец = время.время()
печать (конец - начало)
 

0,116992250977
 

Чтобы найти элемент, потребовалось всего 0,1 секунды, и мы нашли выигрышное решение!

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