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

все функции и методы с примерами

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

В Python есть модуль с именем time для обработки задач, связанных со временем. Чтобы использовать функции, определенные в модуле, нам нужно сначала импортировать модуль. Вот как:

import time

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

Python time.time()

Функция time() возвращает количество секунд, прошедших с начала эпохи.

Для системы Unix 1 января 1970 г., 00:00:00 по всемирному координированному времени ‒ это эпоха (точка, где начинается время).

import time
seconds = time.time()
print("Seconds since epoch =", seconds)	

time.ctime()

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

import time

# seconds passed since epoch
seconds = 1545925769.9618232
local_time = time.ctime(seconds)
print("Local time:", local_time)	

Если вы запустите программу, результат будет примерно таким:

Local time: Thu Dec 27 15:49:29 2018

 

time.sleep()

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

import time

print("This is printed immediately.")
time.sleep(2.4)
print("This is printed after 2.4 seconds.")

Прежде чем говорить о других функциях, связанных со временем, давайте кратко рассмотрим класс time.struct_time.

Класс time.struct_time

Некоторые функции в модуле времени, такие как gmtime(), asctime() и т.д., либо принимают объект time.struct_time в качестве аргумента, либо возвращают его.

Вот пример объекта time. struct_time:

time.struct_time(tm_year=2018, tm_mon=12, tm_mday=27, 
                    tm_hour=6, tm_min=35, tm_sec=17, 
                    tm_wday=3, tm_yday=361, tm_isdst=0)

Индекс	Атрибут	Значение
0	tm_year	0000, …., 2018, …, 9999
1	tm_mon	1, 2, …, 12
2	tm_mday	1, 2, …, 31
3	tm_hour	0, 1, …, 23
4	tm_min	0, 1, …, 59
5	tm_sec	0, 1, …, 61
6	tm_wday	0, 1, …, 6; Понедельник 0
7	tm_yday	1, 2, …, 366
8	tm_isdst	0, 1 или -1

Значения (элементы) объекта time.struct_time доступны как с помощью индексов, так и атрибутов.

time.

localtime()

Функция localtime() в Python принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает struct_time по местному времени.

import time

result = time.localtime(1545925769)
print("result:", result)
print("\nyear:", result.tm_year)
print("tm_hour:", result.tm_hour)

Когда вы запустите программу, результат будет примерно таким:

result: time.struct_time(tm_year=2018, tm_mon=12, tm_mday=27, tm_hour=15, tm_min=49, tm_sec=29, tm_wday=3, tm_yday=361, tm_isdst=0)

year: 2018
tm_hour: 15

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

time.gmtime()

Функция gmtime() принимает в качестве аргумента количество секунд, прошедших с начала эпохи, и возвращает struct_time в формате UTC.

import time

result = time. gmtime(1545925769)
print("result:", result)
print("\nyear:", result.tm_year)
print("tm_hour:", result.tm_hour)

Когда вы запустите программу, вывод будет:

result = time.struct_time(tm_year=2018, tm_mon=12, tm_mday=28, tm_hour=8, tm_min=44, tm_sec=4, tm_wday=4, tm_yday=362, tm_isdst=0)

year = 2018
tm_hour = 8

Если в gmtime() не передается аргумент или None, используется значение, возвращаемое time().

time.mktime()

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

import time

t = (2018, 12, 28, 8, 44, 4, 4, 362, 0)

local_time = time.mktime(t)
print("Local time:", local_time)

В приведенном ниже примере показано, как связаны mktime() и localtime():

import time

seconds = 1545925769

# returns struct_time
t = time. localtime(seconds)
print("t1: ", t)

# returns seconds from struct_time
s = time.mktime(t)
print("\s:", seconds)

Когда вы запустите программу, результат будет примерно таким:

t1:  time.struct_time(tm_year=2018, tm_mon=12, tm_mday=27, tm_hour=15, tm_min=49, tm_sec=29, tm_wday=3, tm_yday=361, tm_isdst=0)

s: 1545925769.0

time.asctime()

Функция asctime() принимает struct_time (или кортеж, содержащий 9 элементов, соответствующих struct_time) в качестве аргумента и возвращает строку, представляющую его. Вот пример:

import time

t = (2018, 12, 28, 8, 44, 4, 4, 362, 0)

result = time.asctime(t)
print("Result:", result)

Когда вы запустите программу, вывод будет:

Result: Fri Dec 28 08:44:04 2018

time.strftime()

Функция strftime() принимает struct_time (или соответствующий ей кортеж) в качестве аргумента и возвращает строку, представляющую ее на основе используемого кода формата.

Например:

import time

named_tuple = time.localtime() # get struct_time
time_string = time.strftime("%m/%d/%Y, %H:%M:%S", named_tuple)

print(time_string)

Когда вы запустите программу, результат будет примерно таким:

12/28/2018, 09:47:41

Здесь % Y,% m,% d,% H и т.д. являются кодами формата:

• % Y ‒ год [0001, …, 2018, 2019, …, 9999]
• % m ‒ месяц [01, 02, …, 11, 12]
• % d ‒ день [01, 02, …, 30, 31]
• % H ‒ час [00, 01, …, 22, 23
• % M ‒ минуты [00, 01, …, 58, 59]
• % S ‒ секунда [00, 01, …, 58, 61]

time.strptime()

strptime() анализирует строку, представляющую время, и возвращает struct_time.

import time

time_string = "21 June, 2018"
result = time.strptime(time_string, "%d %B, %Y")

print(result)

Когда вы запустите программу, вывод будет:

time. struct_time(tm_year=2018, tm_mon=6, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=172, tm_isdst=-1)

50101cookie-checkМодуль time в Pythonyes

Практическое руководство по путешествию во времени с Python | by Andrew Prog

В Python есть несколько встроенных библиотек для работы со временем и интервалами времени: time, datatime, calendar, timeit. Но когда какой модуль использовать? Рассмотрим на примерах.

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

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

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

Работа с модулем 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)

Итак, модуль 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

Распространенная задача — преобразование объектов указанных типов в строки вида 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, не используя все девять позиций кортежа. Неизвестные элементы вычисляются или на их место подставляются значения по умолчанию.

Одна из наиболее часто используемых функций модуля 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 *= istart = 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)

Первоисточник: https://proglib. io/p/nazad-v-budushchee-prakticheskoe-rukovodstvo-po-puteshestviyu-vo-vremeni-s-python-2019-12-01

python — Как узнать текущее время?

Модуль

time

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

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

Время эпохи Unix

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

 >>> time.time()
1424233311.771502
 

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

Однако это не идеально для планирования человеком. Если у вас есть будущее событие, которое вы хотите провести в определенный момент времени, вы захотите сохранить это время в строке, которую можно разобрать на 9объект 0005 datetime или сериализованный объект datetime (они будут описаны позже).

time.ctime

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

 >>> время.ctime()
'Вт, 17 февраля, 23:21:56 2015'
 

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

 >>> time.ctime(1424233311.771502)
'Вт, 17 февраля, 23:21:51 2015'
 

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

модуль datetime

Модуль datetime также весьма полезен здесь:

 >>> import datetime
 

datetime.datetime.now

datetime.now — это метод класса, который возвращает текущее время. Он использует time.localtime без информации о часовом поясе (если она не указана, в противном случае см. сведения о часовом поясе ниже). У него есть представление (которое позволит вам воссоздать эквивалентный объект), отображаемое в оболочке, но при печати (или принудительное преобразование в str ), он имеет удобочитаемый (и почти ISO) формат, а лексикографическая сортировка эквивалентна хронологической сортировке:

 >>> datetime.datetime.now()
datetime.datetime(2015, 2, 17, 23, 43, 49, 94252)
>>> print(datetime.datetime.now())
2015-02-17 23:43:51.782461
 

datetime’s

utcnow

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

 >>> datetime. datetime.utcnow()
datetime.datetime(2015, 2, 18, 4, 53, 28, 394163)
>>> print(datetime.datetime.utcnow())
2015-02-18 04:53:31.783988
 

UTC — это стандарт времени, почти эквивалентный часовому поясу GMT. (Хотя GMT и UTC не изменяются для перехода на летнее время, их пользователи могут переключаться на другие часовые пояса, например, на британское летнее время, в течение лета.)

datetime timezone осведомленный

far можно легко преобразовать в различные часовые пояса. Мы можем решить эту проблему с помощью pytz модуль:

 >>> импорт pytz
>>> затем = datetime.datetime.now(pytz.utc)
>>> тогда
datetime.datetime(2015, 2, 18, 4, 55, 58, 753949, tzinfo=)
 

Эквивалентно, в Python 3 у нас есть класс timezone с прикрепленным экземпляром utc timezone , который также делает часовой пояс объекта осведомленным (но преобразование в другой часовой пояс без удобного модуля pytz остается в качестве упражнения для считыватель):

 >>> datetime. datetime.now(datetime.timezone.utc)
datetime.datetime(2015, 2, 18, 22, 31, 56, 564191, tzinfo=datetime.timezone.utc)
 

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

 >>> напечатать(затем)
2015-02-18 04:55:58.753949+00:00
>>> print(then.astimezone(pytz.timezone('США/Восток')))
2015-02-17 23:55:58.753949-05:00
 

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

 >>> pytz.utc.localize(datetime.datetime.utcnow( ))
datetime.datetime(2015, 2, 18, 6, 6, 29, 32285, tzinfo=)
>>> datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
datetime.datetime(2015, 2, 18, 6, 9, 30, 728550, tzinfo=)
 

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

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

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

Если вы показываете время с помощью Python для пользователя, ctime прекрасно работает, не в таблице (обычно она плохо сортируется), а, возможно, в часах. Тем не менее, я лично рекомендую при работе со временем в Python либо использовать время Unix, либо объект UTC datetime с учетом часового пояса.

Как узнать время выполнения программы Python?

Задавать вопрос

спросил 13 лет, 5 месяцев назад

Изменено 3 месяца назад

Просмотрено 2,3 млн раз

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

Я просмотрел модуль timeit , но, похоже, он предназначен только для небольших фрагментов кода. Я хочу засечь всю программу.

• питон
• время
• время выполнения

1

Самый простой способ в Python:

 время импорта
start_time = время.время()
основной()
print("--- %s секунд ---" % (time.time() - start_time))
 

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

Печать:

 --- 0,764891862869 секунд ---
 

10

В Linux или Unix:

 $ time python yourprogram.py
 

В Windows см. этот вопрос StackOverflow: Как измерить время выполнения команды в командной строке Windows?

Для более подробного вывода

 $ time -v python yourprogram. py
    Время выполнения команды: «python3 yourprogram.py»
    Время пользователя (секунды): 0,08
    Системное время (секунды): 0,02
    Процент загрузки процессора этой работой: 98%
    Прошедшее (настенные часы) время (ч:мм:сс или м:сс): 0:00,10
    Средний размер общего текста (кбайт): 0
    Средний размер нераспределенных данных (кбайт): 0
    Средний размер стека (кбайт): 0
    Средний общий размер (кбайт): 0
    Максимальный размер резидентного набора (кбайт): 9480
    Средний размер резидентного набора (кбайт): 0
    Основные (требующие ввода-вывода) ошибки страницы: 0
    Незначительные (восстановление кадра) ошибки страницы: 1114
    Произвольные переключения контекста: 0
    Непроизвольные переключения контекста: 22
    Свопы: 0
    Входы файловой системы: 0
    Выходы файловой системы: 0
    Отправлено сообщений через сокет: 0
    Получено сообщений через сокет: 0
    Доставлено сигналов: 0
    Размер страницы (байт): 4096
    Статус выхода: 0
 

4

Ставлю этот Timing. py в мой собственный каталог site-packages и просто вставьте время импорта вверху моего модуля:

 import atexit
часы импорта времени
определение секундToStr(t):
    вернуть "%d:%02d:%02d.%03d" % \
        уменьшить (лямбда ll, b : divmod (ll [0], b) + ll [1:],
            [(t*1000,),1000,60,60])
строка = "="*40
журнал деф (с, прошедшее = нет):
    линия печати
    печатать секундыToStr(часы()), '-', с
    если прошло:
        напечатать «Прошедшее время:», истекшее
    линия печати
    Распечатать
деф эндлог():
    конец = часы()
    прошедшее = конец-начало
    log("Завершить программу", secondToStr(истекшее))
определить сейчас():
    вернуть секундыToStr(часы())
начало = часы ()
atexit.register(endlog)
лог("Запустить программу")
 

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

Примечание. Версию приведенного выше кода для Python 3 можно найти здесь или здесь.

7

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

Например:

 из даты и времени импортировать дату и время
start_time = дата и время.сейчас()
# делай свою работу здесь
end_time = дата/время.сейчас()
print('Продолжительность: {}'.format(end_time - start_time))
 

Образец вывода, например.

 Продолжительность: 0:00:08.309267
 

или

 Продолжительность: 1 день, 1:51:24.269711
 

Как упомянул Дж. Ф. Себастьян, этот подход может столкнуться с некоторыми сложными случаями с местным временем, поэтому его безопаснее использовать:

 время импорта
из datetime импортировать timedelta
start_time = время. monotonic()
end_time = время.monotonic()
печать (timedelta (секунды = конечное_время - начальное_время))
 

3

 время импорта
start_time = время.часы()
основной()
print(time.clock() - start_time, "секунды")
 

time.clock() возвращает время процессора, что позволяет нам рассчитать только время, используемое этим процессом (во всяком случае, в Unix). В документации говорится: «В любом случае, эту функцию следует использовать для тестирования Python или алгоритмов синхронизации»9.0011

3

Мне очень нравится ответ Пола Макгуайра, но я использую Python 3. Итак, для тех, кому интересно: вот модификация его ответа, которая работает с Python 3 на * nix (я полагаю, под Windows, что clock() должны использоваться вместо time() ):

 #python3
импортировать атексит
из времени импорта времени, strftime, локальное время
из datetime импортировать timedelta
def секундToStr (истекшее время = нет):
    если истекло None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    еще:
        вернуть строку (timedelta (секунды = прошедшее))
журнал деф (с, прошедшее = нет):
    строка = "="*40
    печать (строка)
    печать (secondsToStr(), '-', с)
    если прошло:
        print("Прошедшее время:", истекшее)
    печать (строка)
    Распечатать()
деф эндлог():
    конец = время ()
    прошедшее = конец-начало
    log("Завершить программу", secondToStr(истекшее))
начало = время ()
atexit. register(endlog)
лог("Запустить программу")
 

Если вы сочтете это полезным, вы все равно должны проголосовать за его ответ, а не за этот, так как он проделал большую часть работы ;).

7

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

Вот пример того, как профилировать скрипт с помощью cProfile из командной строки:

 $ python -m cProfile euler048.py
1007 вызовов функций за 0,061 секунды ЦП
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
    1 0,000 0,000 0,061 0,061 <строка>:1(<модуль>)
 1000 0,051 0,000 0,051 0,000 euler048. py:2(<лямбда>)
    1 0,005 0,005 0,061 0,061 euler048.py:2(<модуль>)
    1 0,000 0,000 0,061 0,061 {исполняемый файл}
    1 0,002 0,002 0,053 0,053 {карта}
    1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler}
    1 0,000 0,000 0,000 0,000 {диапазон}
    1 0,003 0,003 0,003 0,003 {сумма}
 

2

Просто используйте модуль timeit . Он работает как с Python 2, так и с Python 3.

 import timeit
start = timeit.default_timer()
# Все операторы программы
стоп = timeit.default_timer()
время_исполнения = стоп-старт
print("Программа выполнена за "+str(execution_time)) # Возвращает время в секундах
 

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

 def sample_function (начало, ** kwargs):
     пытаться:
         # Ваши заявления
     кроме:
         # операторы exclude запускаются, когда ваши операторы вызывают исключение
         стоп = timeit. default_timer()
         время_исполнения = стоп-старт
         print("Программа выполнена в " + str(время_выполнения))
 

1

время.часы()

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

time.perf_counter()

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

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

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

 начало = время.процесс_время()
... сделай что-нибудь
прошедшее = (time.process_time() - начало)
 

1

time.clock устарел в Python 3.3 и будет удален из Python 3.8: используйте time.perf_counter или time.process_time вместо

 время импорта
start_time = время.perf_counter ()
для x в диапазоне (1, 100):
    печать (х)
end_time = time.perf_counter ()
print(end_time - start_time, "секунды")
 

1

Для пользователей данных, использующих Jupyter Notebook

В ячейке вы можете использовать волшебную команду Jupyter %%time для измерения времени выполнения:

 %%time
[ x**2 для x в диапазоне (10000)]
 

Вывод

 Время процессора: пользователь 4,54 мс, системный: 0 нс, всего: 4,54 мс
Время стены: 4,12 мс
 

Будет фиксироваться только время выполнения конкретной ячейки. Если вы хотите зафиксировать время выполнения всей записной книжки (т. е. программы), вы можете создать новую записную книжку в том же каталоге и в новой записной книжке выполнить все ячейки:

Предположим, указанная выше записная книжка называется example_notebook. IPINB . В новом блокноте в том же каталоге:

 # Преобразуйте свой блокнот в сценарий .py:
!jupyter nbconvert --в скрипт example_notebook.ipynb
# Запускаем example_notebook с флагом -t для времени
%run -t пример_блокнота
 

Вывод

 Тайминги процессора IPython (приблизительно):
  Пользователь: 0,00 с.
  Система : 0,00 с.
Время стены: 0,00 с.
 

Следующий фрагмент выводит прошедшее время в удобном для восприятия человеком формате <ЧЧ:ММ:СС> .

 время импорта
из datetime импортировать timedelta
start_time = время.время()
#
# Выполнить множество вычислений.
#
прошедшее_время_секунд = время.время() - время начала
msg = "Выполнение заняло: %s секунд (время настенных часов)" % timedelta(seconds=round(elapsed_time_secs))
печать (сообщение)
 

1

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

 время импорта
start_time = время.время()
основной()
секунды = время.время() - время_начала
print('Затраченное время:', time.strftime("%H:%M:%S",time.gmtime(секунды)))
 

Образец вывода

 Затраченное время: 00:00:08
 

1

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

 определение времени (метод):
    def timed(*args, **kwargs):
        тс = время.время()
        результат = метод (* аргументы, ** kwargs)
        te = время.время()
        если 'log_time' в kwargs:
            name = kwargs.get('log_name', method.__name__.upper())
            kwargs['log_time'][имя] = int((te - ts) * 1000)
        еще:
            print('%r %2.22f мс' % (метод.__name__, (te - ts) * 1000))
        вернуть результат
    возвращение по времени
@timeit
деффу():
    поработай немного()
# Фу()
# 'фу' 0.000953 мс
 

3

 от времени импорта времени
время_начала = время()
. ..
время окончания = время()
time_taken = end_time - start_time # time_taken в секундах
часы, отдых = divmod(time_taken,3600)
минуты, секунды = divmod(остальное, 60)
 

Я просмотрел модуль timeit, но, похоже, он предназначен только для небольших фрагментов кода. Я хочу засечь всю программу.

 $ python -mtimeit -n1 -r1 -t -s "из вашего_модуля импортировать основной" "основной()"
 

Он запускает функцию your_module.main() один раз и печатает прошедшее время, используя функцию time.time() в качестве таймера.

Чтобы эмулировать /usr/bin/time в Python, см. Подпроцесс Python с /usr/bin/time: как получить информацию о времени, но игнорировать все остальные выходные данные?.

Чтобы измерить время процессора (например, не включать время в течение time.sleep() ) для каждой функции, вы можете использовать модуль profile ( cProfile на Python 2):

 $ python3 -mprofile your_module. py
 

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

См. Как профилировать скрипт Python?

У меня была та же проблема во многих местах, поэтому я создал удобный пакет horology . Вы можете установить его с помощью pip install horology , а затем сделать это элегантным способом:

 из horology import Timing.
with Timing(name='Важные расчеты:'):
    подготовить()
    делай_ваши_вещи()
    Finish_sth()
 

выведет:

 Важные вычисления: 12,43 мс
 

Или еще проще (если у вас есть одна функция):

 из часового импорта по времени
@время
деф основной():
    ...
 

будет выводить:

 основной: 7,12 ч
 

Учитывает единицы и округление. Он работает с Python 3.6 или новее.

4

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

 импорт даты и времени как DT
импортировать время
класс TimingManager (объект):
    """Диспетчер контекста используется с оператором with для определения времени выполнения.
    Пример:
    с TimingManager() как t:
       # Код времени
    """
    часы = timeit.default_timer
    защита __enter__(сам):
        """
        """
        self.start = self.часы ()
        self.log('\n=> Время начала: {}')
        вернуть себя
    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        """
        self.endlog()
        вернуть ложь
    журнал защиты (я, с, прошедшее = нет):
        """Запишите текущее время и прошедшее время, если они есть.
        :param s: Текст для отображения, используйте '{}' для форматирования текста с помощью
            текущее время.
        :param elapsed: Прошедшее время для отображения. По умолчанию: Нет, нет отображения.
        """
        напечатать s.format (self._secondsToStr (self.clock ()))
        если (прошедшее не равно None):
            print 'Прошедшее время: {}\n'. format(истекшее)
    деф эндлог(я):
        """Зарегистрируйте время окончания выполнения с прошедшим временем.
        """
        self.log('=> Время окончания: {}', self.now())
    определить сейчас (я):
        """Возвращает текущее прошедшее время в виде строки чч:мм:сс.
        :возврат: Строка.
        """
        вернуть строку (dt.timedelta (секунды = self.clock () - self.start))
    def _secondsToStr(я, сек):
        """Преобразовать метку времени в строку ч:мм:сс.
        :param sec: Отметка времени.
        """
        вернуть строку (dt.datetime.fromtimestamp (сек))
 

В IPython «timeit» любой скрипт:

 def foo():
    %run bar.py
время это foo ()
 

1

Использовать line_profiler.

line_profiler профилирует время выполнения отдельных строк кода. Профилировщик реализован на C через Cython, чтобы уменьшить накладные расходы на профилирование.

 из импорта line_profiler LineProfiler
импортировать случайный
деф do_stuff (числа):
    с = сумма (числа)
    l = [числа [i]/43 для i в диапазоне (len (числа))]
    m = ['hello'+str(numbers[i]) для i в диапазоне(len(numbers))]
числа = [random. randint(1,100) для i в диапазоне(1000)]
lp = LineProfiler()
lp_wrapper = lp(делаем_вещи)
lp_wrapper (числа)
lp.print_stats()
 

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

 Единица таймера: 1e-06 с
Общее время: 0,000649 с
Файл: 
Функция: do_stuff в строке 4
Строка № совпадений Время на попадание % времени Содержимое строки
================================================== ============
     4 def do_stuff(числа):
     5 1 10 10,0 1,5 с = сумма (числа)
     6 1 186 186,0 28,7 l = [числа[i]/43 для i в диапазоне(len(числа))]
     7 1 453 453,0 69.8 m = ['hello'+str(numbers[i]) для i в диапазоне(len(numbers))]
 

1

Я использовал очень простую функцию для определения времени выполнения части кода:

 время импорта
определение времени():
    start_time = время.время()
    вернуть лямбда x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
 

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

 т = синхронизация()
поезд = pd.read_csv('train.csv',
                        дтип = {
                            'идентификатор': ул,
                            'vendor_id': ул,
                            'pickup_datetime': ул,
                            'dropoff_datetime': ул,
                            'количество_пассажиров': целое,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': ул,
                            'trip_duration': целое,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Загружены данные {} строк из 'train'".format(len(train)))
 

Тогда вывод будет выглядеть так:

 [9,35 с] Загружено 1458644 строки данных из «поезда»
 

0

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

 время импорта
start_time = время.perf_counter()
[основной код здесь]
print (time.perf_counter() - start_time, "секунды")
 

1

Ответить позже, но я использую встроенный время :

 время импорта
код_к_тесту = """
а = диапазон (100000)
б = []
для я в:
    б. добавить (я * 2)
"""
elapsed_time = timeit.timeit (code_to_test, число = 500)
печать (прошедшее_время)
# 10.159821493085474
 

---

• Оберните весь свой код, включая любой импорт, который у вас может быть, внутри code_to_test .
• число Аргумент указывает, сколько раз должен повторяться код.
• Демо

3

Timeit — это класс Python, используемый для расчета времени выполнения небольших блоков кода.

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

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

 из timeit импортировать default_timer как таймер
старт = таймер ()
# Немного логики
конец = таймер()
print("Затраченное время:", конец-начало)
 

0

Сначала установите дружественный к человеку пакет, открыв командную строку (CMD) от имени администратора и набрав там — pip install humanfriendly

Код:

 from humanfriendly import format_timespan
время импорта
начало_время = время.время()
# Поместите сюда свой код
конечное_время = время.время() - начало_время
print("Общее время выполнения: ", format_timespan(end_time))
 

Вывод:

Вы делаете это просто в Python. Не нужно усложнять.

 время импорта
начало = время.местное время()
конец = время.местное время()
"""Общее время выполнения в минутах$ """
печать (конец. tm_min - начало.tm_min)
"""Общее время выполнения в секундах$ """
печать (конец.tm_sec - начало.tm_sec)
 

1

Существует модуль timeit , который можно использовать для измерения времени выполнения кода Python.

Подробная документация и примеры в документации Python, 26.6. timeit — Измерение времени выполнения небольших фрагментов кода .

1

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

 время импорта
из datetime импортировать timedelta
def start_time_measure (сообщение = нет):
    если сообщение:
        распечатать (сообщение)
    время возврата.monotonic()
def end_time_measure (start_time, print_prefix = None):
    end_time = время.monotonic()
    если print_prefix:
        print(print_prefix + str(timedelta(seconds=end_time - start_time)))
    вернуть конечное_время
 

Использование:

 total_start_time = start_time_measure()
start_time = start_time_measure('Делаем что-то. ..')
# Сделай что-нибудь
end_time_measure(start_time, 'Выполнено через:')
start_time = start_time_measure('Делаю что-то еще...')
# Сделайте что-нибудь еще
end_time_measure(start_time, 'Выполнено через:')
end_time_measure(total_start_time, 'Общее время:')
 

Вывод:

 Что-то делать...
Выполнено в: 0:00:01.218000
Делать что-то другое...
Выполнено в: 0:00:01.313000
Общее время: 0:00:02.672000
 

Это ответ Пола Макгуайра, который мне подходит. На всякий случай, если у кого-то возникли проблемы с запуском этого.

 импорт атэкзит
часы импорта времени
def уменьшить (функция, итерируемый, инициализатор = нет):
    это = итер (повторяемый)
    если инициализатор None:
        значение = следующее (оно)
    еще:
        значение = инициализатор
    для элемента в нем:
        значение = функция (значение, элемент)
    возвращаемое значение
определение секундToStr(t):
    вернуть "%d:%02d:%02d.%03d" % \
        уменьшить (лямбда ll, b : divmod (ll [0], b) + ll [1:],
            [(t*1000,),1000,60,60])
строка = "="*40
журнал деф (с, прошедшее = нет):
    печать (строка)
    печать (secondsToStr(часы()), '-', с)
    если прошло:
        печать ("Прошедшее время:", истекло)
    печать (строка)
деф эндлог():
    конец = часы()
    прошедшее = конец-начало
    log("Завершить программу", secondToStr(истекшее))
определить сейчас():
    вернуть секундыToStr(часы())
деф основной():
    начало = часы ()
    atexit. register(endlog)
    лог("Запустить программу")
 

Вызовите time.main() из вашей программы после импорта файла.

Время выполнения программы Python может быть непоследовательным в зависимости от:

• Одна и та же программа может оцениваться с использованием разных алгоритмов
• Время выполнения зависит от алгоритма
• Время работы зависит от реализации
• Время работы зависит от компьютера
• Время выполнения непредсказуемо из-за небольших входных данных

Это потому, что наиболее эффективным способом является использование «Порядка роста» и изучение нотации «Большой О», чтобы сделать это правильно.

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

 время импорта
сейчас = время.время()
будущее = сейчас + 10
step = 4 # Почему 4 шага? Потому что до сих пор выполнено уже четыре операции
в то время как time.
No related posts.