Python time module

Структура DateTime

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

Для работы с датами и временем в .NET предназначена структура DateTime. Она представляет дату и время от 00:00:00 1 января 0001 года
до 23:59:59 31 декабря 9999 года.

Для создания нового объекта DateTime также можно использовать конструктор. Пустой конструктор создает начальную дату:

DateTime date1 = new DateTime();
Console.WriteLine(date1); // 01.01.0001 0:00:00

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

Console.WriteLine(DateTime.MinValue);

Чтобы задать конкретную дату, нужно использовать один из конструкторов, принимающих параметры:

DateTime date1 = new DateTime(2015, 7, 20); // год - месяц - день
Console.WriteLine(date1); // 20.07.2015 0:00:00

Установка времени:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // год - месяц - день - час - минута - секунда
Console.WriteLine(date1); // 20.07.2015 18:30:25

Если необходимо получить текущую время и дату, то можно использовать ряд свойств DateTime:

Console.WriteLine(DateTime.Now);
Console.WriteLine(DateTime.UtcNow);
Console.WriteLine(DateTime.Today);

Консольный вывод:

20.07.2015 11:43:33
20.07.2015 8:43:33
20.07.2015 0:00:00

Свойство берет текущую дату и время компьютера, — дата и время относительно времени по
Гринвичу (GMT) и — только текущая дата.

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

DateTime someDate = new DateTime(1582, 10, 5);
Console.WriteLine(someDate.DayOfWeek);

Консоль выстветит значение Tuesday, то есть вторник. Однако, как может быть известно из истории, впервые переход с юлианского календаря на григорианский
состоялся в октябре 1582 года. Тогда после даты 4 октября (четверг) (еще по юлианскому календарю) сразу перешли к 15 октября (пятница)(уже по григорианскому календарю).
Таким образом, фактически выкинули 10 дней. То есть после 4 октября шло 15 октября.

В большинстве случаев данный факт вряд ли как-то повлияет на вычисления, однако при работе с очень давними датами данный аспект следует учитывать.

Операции с DateTime

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

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

• : добавляет к дате значение TimeSpan

• : добавляет к текущей дате несколько дней

• : добавляет к текущей дате несколько часов

• : добавляет к текущей дате несколько минут

• : добавляет к текущей дате несколько месяцев

• : добавляет к текущей дате несколько лет

Например, добавим к некоторой дате 3 часа:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // 20.07.2015 18:30:25
Console.WriteLine(date1.AddHours(3)); // 20.07.2015 21:30:25

Для вычитания дат используется метод Substract(DateTime date):

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // 20.07.2015 18:30:25
DateTime date2 = new DateTime(2015, 7, 20, 15, 30, 25); // 20.07.2015 15:30:25
Console.WriteLine(date1.Subtract(date2)); // 03:00:00

Здесь даты различаются на три часа, поэтому результатом будет дата «03:00:00».

Метод Substract не имеет возможностей для отдельного вычитания дней, часов и так далее. Но это и не надо, так как мы можем передавать в метод
AddDays() и другие методы добавления отрицательные значения:

// вычтем три часа
DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25);  // 20.07.2015 18:30:25
Console.WriteLine(date1.AddHours(-3)); // 20.07.2015 15:30:25

Кроме операций сложения и вычитания еще есть ряд методов форматирования дат:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25);
Console.WriteLine(date1.ToLocalTime()); // 20.07.2015 21:30:25
Console.WriteLine(date1.ToUniversalTime()); // 20.07.2015 15:30:25
Console.WriteLine(date1.ToLongDateString()); // 20 июля 2015 г.
Console.WriteLine(date1.ToShortDateString()); // 20.07.2015
Console.WriteLine(date1.ToLongTimeString()); // 18:30:25
Console.WriteLine(date1.ToShortTimeString()); // 18:30

Метод преобразует время UTC в локальное время, добавляя смещение относительно времени по Гринвичу.
Метод , наоборот, преобразует локальное время во время UTC, то есть вычитает смещение относительно времени по Гринвичу.
Остальные методы преобразуют дату к определенному формату.

НазадВперед

Использование модуля времени

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

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

Чтобы вывести эпоху в вашей системе, используйте следующую строку кода:

time.gmtime(0)

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

time.strftime("%H:%M:%S", time.gmtime(n))

Эта строка принимает время в секундах как «n», а затем позволяет отдельно выводить часы, минуты и секунды.

Полный код Python выглядит следующим образом:

import time
n=10000
time_format = time.strftime("%H:%M:%S", time.gmtime(n))
print("Time in preferred format :-",time_format)

Вывод :

Time in preferred format :- 02:46:40

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

% а	Отображать сокращенное название дня недели.
% А	Отображать полное название дня недели.
% b	Отображать сокращенное название месяца.
% B	Отображать полное название месяца.
% c	Отобразить соответствующее представление даты и времени.
% d	Отображать день месяца как десятичное число .

Попробуем использовать% a и % b.

import time
n=100000000000
time_format = time.strftime("Day: %a, Time: %H:%M:%S, Month: %b", time.gmtime(n))
print("Time in preferred format :-",time_format)

Вывод :

Time in preferred format :- Day: Wed, Time: 09:46:40, Month: Nov

Базовый пример

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

timeit_example.py

import timeit

# using setitem
t  timeit.Timer("print('main statement')", "print('setup')")

print('TIMEIT:')
print(t.timeit(2))

print('REPEAT:')
print(t.repeat(3, 2))

При запуске вывод показывает результаты повторных вызовов .

$ python3 timeit_example.py

TIMEIT:
setup
main statement
main statement
1.8429999999944324e-06
REPEAT:
setup
main statement
main statement
setup
main statement
main statement
setup
main statement
main statement

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

Когда используется , он вызывает несколько раз (в данном случае 3 раза), и все ответы возвращаются в виде списка.

Understanding Time Zones

A time zone is a region of the world that conforms to a standardized time. Time zones are defined by their offset from Coordinated Universal Time (UTC) and, potentially, the inclusion of daylight savings time (which we’ll cover in more detail later in this article).

Fun Fact: If you’re a native English speaker, you might be wondering why the abbreviation for “Coordinated Universal Time” is UTC rather than the more obvious CUT. However, if you’re a native French speaker, you would call it “Temps Universel Coordonné,” which suggests a different abbreviation: TUC.

Ultimately, the as the official abbreviation so that, regardless of language, the abbreviation would be the same.

Python Timer Decorators

Декораторы-это дополнительная поддержка для любого вида функций. Также называемый метапрограммированием, вы можете изменить/добавить к нему функциональность. Python Timer Decorators-это самый простой способ реализации функций таймера в python. После объявления вы можете использовать декораторы в одной строке, даже не зная их. Кроме того, вы можете применить их к каждой функции в вашем коде, чтобы проверить, какой код занимает больше всего времени для выполнения.

Синтаксис –

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

Пример –

import time

def check_time(func):
    def inner(*args, **kwargs):
       .time()
        func(*args, **kwargs)
       .time()
        print("Time taken to execute function is ", end-start)
    return inner


@check_time
def task():
    # do something
    for i in range(10000000):
       
        pass


task()

Выход –

Объяснение –

Как обычно, мы начинаем с импорта самого важного модуля из python “time.” Затем мы создаем декоратор с именем “check_time.” Внутри него мы добавляем вложенную внутреннюю функцию, где мы можем создавать ссылки на время. Эти две ссылки расположены так, что обе они находятся между выполнением функции

Далее мы создаем тестовую функцию с именем “задача”, чтобы проверить, работает ли наша задача. Затем добавьте сверху декоратора. Как<сильный> декоратор будет творить свою магию и печатать время, затраченное функцией.

Suspending Execution

One really useful Python time function is , which suspends the thread’s execution for a specified amount of time.

For example, you can suspend your program’s execution for 10 seconds like this:

>>>

Your program will print the first formatted string, then pause for 10 seconds, and finally print the second formatted string.

You can also pass fractional seconds to :

>>>

is useful for testing or making your program wait for any reason, but you must be careful not to halt your production code unless you have good reason to do so.

Before Python 3.5, a signal sent to your process could interrupt . However, in 3.5 and later, will always suspend execution for at least the amount of specified time, even if the process receives a signal.

is just one Python time function that can help you test your programs and make them more robust.

Python timeit — интерфейс командной строки

Интерфейс командной строки очень похож на интерфейс запуска программы Python.

Вам необходимо импортировать внешний модуль с помощью опции -m и применить его к вашему коду.

python -m timeit 'print("Hello from AskPython")'

Это запустит фрагмент, переданный в виде строки, с использованием .

По умолчанию это будет запускать код 1 миллион раз в Linux и 20 миллионов раз в Windows и измерять лучшее время среди этих значений. Ниже приведены результаты моей системы Linux.

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

Мы также можем использовать через интерпретатор Python и импортировать его, используя:

import timeit

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

execution_time = timeit.timeit(code, number)

Мы можем контролировать количество итераций с помощью параметра .

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.19053685299877543
>>> timeit.timeit('"-".join()', number=10000)
0.172546762998536
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.13625987299747067
>>> 

Примечания для тех, кто вызывает этот метод

Метод иногда используется для преобразования местного времени в время в формате UTC.The method is sometimes used to convert a local time to UTC. Затем вызывается метод для восстановления исходного местного времени.The method is then called to restore the original local time. Однако если исходное время представляет недопустимое время в местном часовом поясе, то два значения местного времени не будут равны.However, if the original time represents an invalid time in the local time zone, the two local time values will not be equal. Дополнительные сведения и пример см. в описании метода.For additional information and an example, see the method.

В системах Windows XP метод распознает только текущее правило коррекции для местного часового пояса, которое применяется ко всем датам, включая даты нижнего уровня (то есть даты, предшествующие дате начала текущего правила коррекции).On Windows XP systems, the method recognizes only the current adjustment rule for the local time zone, which it applies to all dates, including down-level dates (that is, dates that are earlier than the starting date of the current adjustment rule). Приложения, работающие в Windows XP, для которых требуются исторические точные вычисления локальных дат и времени, должны обойти это поведение, используя метод для получения TimeZoneInfo объекта, соответствующего локальному часовому поясу и вызова его метода.Applications running on Windows XP that require historically accurate local date and time calculations must work around this behavior by using the method to retrieve a TimeZoneInfo object that corresponds to the local time zone and calling its method.

В следующем примере показано различие между методами и в системе Windows XP, находящейся в тихоокеанском часовом поясе США.The following example illustrates the difference between the and methods on a Windows XP system in the U.S. Pacific Time zone. Первые два вызова метода применяют текущее правило коррекции часового пояса (которое вступает в действие в 2007) к дате в 2006.The first two method calls apply the current time zone adjustment rule (which went into effect in 2007) to a date in 2006. Текущее правило коррекции обеспечивает переход на летнее время во второе воскресенье марта. предыдущее правило, которое действовало в 2006, было введено для перехода на летнее время в первое воскресенье апреля.The current adjustment rule provides for the transition to daylight saving time on the second Sunday of March; the previous rule, which was in effect in 2006, provided for the transition to daylight saving time to occur on the first Sunday of April. Только третий вызов метода точно выполняет это преобразование исторических дат и времени.Only the third method call accurately performs this historical date and time conversion.

Для определенного часового пояса

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

Вы можете установить с помощью , если вы еще этого не сделали.

pip install pytz

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

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

from datetime import datetime
from pytz import timezone, common_timezones

datetime_object = datetime.now(timezone('Asia/Kolkata'))
print("Current IST:", datetime_object)

Выход

Current IST: 2020-06-27 23:27:49.003020+05:30

from datetime import datetime
from pytz import timezone, common_timezones
import random

for _ in range(4):
    zone = random.choice(common_timezones)
    print(f"Using TimeZone: {zone}")
    datetime_object = datetime.now(timezone(zone))
    print(datetime_object)

Выход

Using TimeZone: America/St_Lucia
2020-06-27 13:57:04.804959-04:00
Using TimeZone: Asia/Muscat
2020-06-27 21:57:04.814959+04:00
Using TimeZone: Asia/Urumqi
2020-06-27 23:57:04.825990+06:00
Using TimeZone: Asia/Seoul
2020-06-28 02:57:04.836994+09:00

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

Measuring Performance

You can use to measure the performance of your program.

The way you do this is to use which, as the name suggests, provides a performance counter with a high resolution to measure short distances of time.

To use , you place a counter before your code begins execution as well as after your code’s execution completes:

>>>

First, captures the moment before you call the function. captures the moment after the function returns. The function’s total execution time took seconds.

Technical Detail: Python 3.7 introduced , which works the same as , but uses nanoseconds instead of seconds.

(or ) is the most precise way to measure the performance of your code using one execution. However, if you’re trying to accurately gauge the performance of a code snippet, I recommend using the Python module.

Модуль time

Модуль основан на «эпохе Unix», которая началась 1 января 1970 года:

>>> import time
>>> print(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, как число с плавающей запятой:

>>> time.time()
1524561056.103065

Функция преобразует время, выраженное в секундах с начала эпохи Unix, в строку вида «Tue Apr 24 10:36:06 2018»:

>>> print(time.ctime())
Tue Apr 24 10:36:06 2018

Функция возвращает время по Гринвичу как объект

>>> time.gmtime()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=24, tm_hour=9, tm_min=6, tm_sec=29, tm_wday=1, tm_yday=114, tm_isdst=0)

Функция возвращает местное время (с учетом часового пояса) как объект

>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=4, tm_mday=24, tm_hour=12, tm_min=6, tm_sec=51, tm_wday=1, tm_yday=114, tm_isdst=0)

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

>>> time.altzone
-14400

Функция приостановливает выполнение скрипта на определенное количество секунд.

Свойства и методы класса

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

Текущая дата и время в Python на часовой пояс

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

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

С другой стороны, это похожая библиотека, которая наследует от datetime модуль. Он использует более чистый подход, что делает его быстрее, чем аналог ( ).

Оба модуля могут быть установлены с помощью следующих Пип команды,

Для модуль:

pip install pytz

Для модуль:

pip install pendulum

Пример

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

import pytz
from datetime import datetime

utc = pytz.timezone('UTC')
pst = pytz.timezone('America/Los_Angeles')
ist = pytz.timezone('Asia/Calcutta')

print("Using pytz Module:")
print('Current Date and Time in UTC =', datetime.now(utc))
print('Current Date and Time in PST =', datetime.now(pst))
print('Current Date and Time in IST =', datetime.now(ist))


import pendulum

utc1 = pendulum.timezone('UTC')
pst1 = pendulum.timezone('America/Los_Angeles')
ist1 = pendulum.timezone('Asia/Calcutta')

print("Using pendulum Module:")
print('Current Date Time in UTC =', datetime.now(utc1))
print('Current Date Time in PST =', datetime.now(pst1))
print('Current Date Time in IST =', datetime.now(ist1))

Выход :

Здесь,

• Для обоих случаев, во-первых, мы используем Метод определен для обоих Пыта и маятник модули при прохождении требуемого часового пояса
• Затем мы передаем эти объекты часового пояса к Метод от datetime класс. Метод возвращает точную дату и время для заданного часового пояса. И, следовательно, мы напрямую распечатаем это.

Возвращение конкретного формата

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

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

Вот фрагмент кода, где мы это делаем.

import time

named_tuple = time.localtime() # получить struct_time

time_string = time.strftime(“%m/%d/%Y, %H:%M:%S”, named_tuple)

print(time_string)

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

1. %Y – год.
2. %m – месяц.
3. %d – день.
4. %H – час.
5. %M – минута.
6. %S – секунда.

Соответственно, можно сделать так, чтобы вывод был исключительно месяца и дня. Для этого просто не надо давать команду выводить год. То есть, записать в приведенной выше формуле в качестве аргумента %m/%d, и все. Или же наоборот, %d/%m. 

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

Сохранение значений в словаре

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

# A few constants
range_size  1000
count  1000
setup_statement  ';'.join(",
    "d = {}",
])

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

def show_results(result):
    "Print microseconds per pass and per item."
    global count, range_size
    per_pass  1000000 * (result / count)
    print('{:6.2f} usec/pass'.format(per_pass), end' ')
    per_item  per_pass / range_size
    print('{:6.2f} usec/item'.format(per_item))


print("{} items".format(range_size))
print("{} iterations".format(count))
print()

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

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

# Using __setitem__ without checking for existing values first
print('__setitem__:', end' ')
t  timeit.Timer(
    textwrap.dedent(
        """
        for s, i in l:
            d = i
        """),
    setup_statement,
)
show_results(t.timeit(numbercount))

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

# Using setdefault
print('setdefault :', end' ')
t  timeit.Timer(
    textwrap.dedent(
        """
        for s, i in l:
            d.setdefault(s, i)
        """),
    setup_statement,
)
show_results(t.timeit(numbercount))

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

# Using exceptions
print('KeyError   :', end' ')
t  timeit.Timer(
    textwrap.dedent(
        """
        for s, i in l:
            try:
                existing = d
            except KeyError:
                d = i
        """),
    setup_statement,
)
show_results(t.timeit(numbercount))

И последний метод использует «», чтобы определить, есть ли в словаре конкретный ключ.

# Using "in"
print('"not in"   :', end' ')
t  timeit.Timer(
    textwrap.dedent(
        """
        for s, i in l:
            if s not in d:
                d = i
        """),
    setup_statement,
)
show_results(t.timeit(numbercount))

При запуске скрипт выдает следующий результат.

$ python3 timeit_dictionary.py

1000 items
1000 iterations

__setitem__:  62.47 usec/pass   0.06 usec/item
setdefault : 122.70 usec/pass   0.12 usec/item
KeyError   :  60.78 usec/pass   0.06 usec/item
"not in"   :  55.79 usec/pass   0.06 usec/item

Это время для MacMini и будет зависеть от того, какое оборудование используется и какие другие программы запущены в системе. Поэкспериментируйте с переменными и , поскольку разные комбинации будут давать разные результаты.

Что дальше: многозадачность и оптимизация

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

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

Что такое TimeTuple?

Многие из функций времени Python обрабатывают время как кортеж из 9 чисел, как показано ниже —

Показатель	поле	Ценности
4-значный год	2016
1	Месяц	От 1 до 12
2	День	От 1 до 31
3	Час	От 0 до 23
4	минут	От 0 до 59
5	второй	От 0 до 61 (60 или 61 — високосные секунды)
6	День недели	От 0 до 6 (0 — понедельник)
7	День года	С 1 по 366 (юлианский день)
8	Дневного сбережения	-1, 0, 1, -1 означает, что библиотека определяет DST

Например —

import time

print (time.localtime());

Это приведет к следующему результату:

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9, 
   tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

Вышеуказанный кортеж эквивалентен структуре struct_time . Эта структура имеет следующие атрибуты —

Показатель	Атрибуты	Ценности
tm_year	2016
1	tm_mon	От 1 до 12
2	tm_mday	От 1 до 31
3	tm_hour	От 0 до 23
4	tm_min	От 0 до 59
5	tm_sec	От 0 до 61 (60 или 61 — високосные секунды)
6	tm_wday	От 0 до 6 (0 — понедельник)
7	tm_yday	С 1 по 366 (юлианский день)
8	tm_isdst	-1, 0, 1, -1 означает, что библиотека определяет DST

Таймер процессора

В то время как time() возвращает время основных часов, clock() возвращает время процессора. Для этого можно использовать Python get time.

Значения, возвращаемые функцией clock(), отражают фактическое время, используемое программой при ее запуске:

time_clock.py
import hashlib
import time
# Данные, используемые для вычисления контрольной суммы md5
data = open(__file__, 'rb').read()
for i in range(5):
    h = hashlib.sha1()
    print(time.ctime(), ': {:0.3f} {:0.3f}'.format(
        time.time(), time.clock()))
    for i in range(300000):
        h.update(data)
    cksum = h.digest()

В этом примере отформатированная ctime() выводится вместе со значениями с плавающей запятой из time() и clock() через цикл для каждой итерации.

Примечание

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

$ python3 time_clock.py
Sun Aug 14 14:10:32 2016 : 1471198232.327 0.033
Sun Aug 14 14:10:32 2016 : 1471198232.705 0.409
Sun Aug 14 14:10:33 2016 : 1471198233.086 0.787
Sun Aug 14 14:10:33 2016 : 1471198233.466 1.166
Sun Aug 14 14:10:33 2016 : 1471198233.842 1.540

Как правило, часы процессора ничего не засекают, если программа ничего не делает:

time_clock_sleep.py
import time
template = '{} - {:0.2f} - {:0.2f}'
print(template.format(
    time.ctime(), time.time(), time.clock())
)
for i in range(3, 0, -1):
    print('Sleeping', i)
    time.sleep(i)
    print(template.format(
        time.ctime(), time.time(), time.clock())
    )

В этом примере  time sleep python цикл выполняет мало действий, переходя в спящий режим после каждой итерации. Значение time() увеличивается даже тогда, когда приложение находится в спящем режиме, но значение clock() отсутствует:

$ python3 -u time_clock_sleep.py
Sun Aug 14 14:10:34 2016 - 1471198234.28 - 0.03
Sleeping 3
Sun Aug 14 14:10:37 2016 - 1471198237.28 - 0.03
Sleeping 2
Sun Aug 14 14:10:39 2016 - 1471198239.29 - 0.03
Sleeping 1
Sun Aug 14 14:10:40 2016 - 1471198240.29 - 0.03

Вызов sleep() передает управление из текущего потока и указывает ожидать, пока система активирует его. Если программа имеет только один поток, это эффективно блокирует приложение, и оно не работает.

Перезарядка таймера Python

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

import time

class Timer:
    """
        Timer class
    """
    def __init__(self):
       .time()

    '''
    Restarts the timer.
    '''
    def restart(self):
       .time()


    '''
    Returns the time elapsed and resets the counter.
    '''
    def get_new_time(self):
       .time() - self.start
        self.restart()
        return value


    '''
    Prints the time elapsed and resets the counter.
    '''
    def print_new_time(self):
        print (self.get_new_time())


    '''
    Returns the time elapsed (Does not reset the counter).
    '''
    def get_time(self):
        return time.time() - self.start
        self.restart()


    '''
    Prints the time elapsed (Does not reset the counter).
    '''
    def print_time(self):
        print(self.get_time())


    '''
    Returns the time elapsed in HH:mm:ss (Does not reset the counter).
    '''
    def get_time_hhmmss(self):
       .time()
        m,(end - self.start, 60)
        h,(m, 60)
        % (h, m, s)
        return time_str

() #Initialize the timer
#wash clothes for 5 seconds
timer.print_time() #Print the time elapsed since Initialization (in seconds)
#dry clothes for 3 seconds
timer.print_new_time() #Print the time elapsed since Initialization and reset the timer
#burn clothes for 10 seconds
print(str('Task done for ' + str(timer.get_time()) + ' seconds.'))

Добавляем потоки в таймер

Пер­вое, что нам нуж­но сде­лать, — выне­сти код таймера-напоминания в отдель­ную функ­цию, что­бы создать с ней поток. Для это­го исполь­зу­ем коман­ду def:

Теперь сде­ла­ем новый поток, в кото­рый отпра­вим выпол­нять­ся нашу новую функ­цию. Так как аргу­мен­тов у нас нет, то и аргу­мен­ты пере­да­вать не будем, а напи­шем args=().

# Создаём новый поток

th = Thread(target=remind, args=())

# И запускаем его

th.start()

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

# Пока работает поток, выведем что-то на экран через 20 секунд после запуска

time.sleep(20)

print(«Пока поток работает, мы можем сделать что-нибудь ещё.\n»)

Резуль­тат:

Готовый код

The time Module

There is a popular time module available in Python which provides functions for working with times and for converting between representations. Here is the list of all available methods −

Sr.No.	Function with Description
1	time.altzone The offset of the local DST timezone, in seconds west of UTC, if one is defined. This is negative if the local DST timezone is east of UTC (as in Western Europe, including the UK). Only use this if daylight is nonzero.
2	time.asctime() Accepts a time-tuple and returns a readable 24-character string such as ‘Tue Dec 11 18:07:14 2008’.
3	time.clock( ) Returns the current CPU time as a floating-point number of seconds. To measure computational costs of different approaches, the value of time.clock is more useful than that of time.time().
4	time.ctime() Like asctime(localtime(secs)) and without arguments is like asctime( )
5	time.gmtime() Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the UTC time. Note : t.tm_isdst is always 0
6	time.localtime() Accepts an instant expressed in seconds since the epoch and returns a time-tuple t with the local time (t.tm_isdst is 0 or 1, depending on whether DST applies to instant secs by local rules).
7	time.mktime(tupletime) Accepts an instant expressed as a time-tuple in local time and returns a floating-point value with the instant expressed in seconds since the epoch.
8	time.sleep(secs) Suspends the calling thread for secs seconds.
9	time.strftime(fmt) Accepts an instant expressed as a time-tuple in local time and returns a string representing the instant as specified by string fmt.
10	time.strptime(str,fmt=’%a %b %d %H:%M:%S %Y’) Parses str according to format string fmt and returns the instant in time-tuple format.
11	time.time( ) Returns the current time instant, a floating-point number of seconds since the epoch.
12	time.tzset() Resets the time conversion rules used by the library routines. The environment variable TZ specifies how this is done.

Let us go through the functions briefly −

There are following two important attributes available with time module −

Sr.No.	Attribute with Description
1	time.timezone Attribute time.timezone is the offset in seconds of the local time zone (without DST) from UTC (>0 in the Americas; <=0 in most of Europe, Asia, Africa).
2	time.tzname Attribute time.tzname is a pair of locale-dependent strings, which are the names of the local time zone without and with DST, respectively.

Вывод даты из 9 чисел, которые относятся к struct_time

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

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

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