Содержание

python — Как можно засечь время выполнения каждой из функций и суммарное время выполнения программы

Чтобы измерить время выполнения программы, можно time команду использовать (часто встроена в shell):

$ time python -c 'import time; time.sleep(1)'
python -c 'import time; time.sleep(1)'  0.01s user 0.00s system 1% cpu 1.021 total

Если команда недоступна, её можно реализовать в Питоне.

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

$ python -m cProfile -s time your_module.py

В графическом виде результаты удобно в KCachegrind просматривать. Пример команд. Больше вариантов: How can you profile a script?

line_profiler позволяет построчно сравнение производить.

Содержание:

  • timeit
  • reporttime.py
  • make-figures.py
  • reporttime + pandas

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

$ python -m timeit -s 'from insertion_sort import sorted; L = list(range(10**5))' 'sorted(L)'

Тот же интерфейс предоставляет pyperf модуль (помимо прочего):

$ python -m pyperf timeit -s '. ..' 'sorted(L)'

Документация утверждает, что pyperf более надёжные результаты выдаёт.

Для интерактивной работы можно %timeit magic в ipython/jupyter notebook использовать.

Оптимизируя выполнение функции, стоит убедиться что она работает корректно (тесты), что изменения действительно ускорили её работу (сравнение производительности). Для этого можно pytest-benchmarkиспользовать.

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

get_functions_with_prefix()). К примеру, если функции в вопросе можно назвать: sorted_selection, sorted_insertion, sorted_bubble и поместить в daedra.py файл:

#!/usr/bin/env python
import random
from reporttime import get_functions_with_prefix, measure
import daedra
funcs = get_functions_with_prefix('sorted_', module=daedra)
for comment, L in [
        ("all same", [1] * 10**3),
        ("range", list(range(10**3))),
        ("random", list(range(10**3)))]:
    if comment == "random":
        random.
 
 shuffle(L)
    measure(funcs, args=[L], comment=comment)

где reporttime.py. measure() функция измеряет производительность функций похожим на python -mtimeit команду способом.

Результаты

name                  time  ratio comment
sorted_insertion  184 usec   1.00 all same
sorted_selection 55.9 msec 303.86 all same
sorted_bubble    59.4 msec 322.92 all same
name                  time  ratio comment
sorted_insertion  186 usec   1.00 range
sorted_selection 57.7 msec 309.44 range
sorted_bubble    60.8 msec 326.40 range
name                  time ratio comment
sorted_selection   58 msec  1.00 random
sorted_insertion 66.2 msec  1.14 random
sorted_bubble     119 msec  2.05 random

Таблица показывает, что на уже отсортированном вводе sorted_insertion() функция заметно выигрывает (в этом случае линейное время для этой функции требуется по сравнению с квадратичным для sorted_selection() и sorted_bubble()). Для случайного ввода, производительность примерно одинаковая. sorted_bubble() хуже во всех вариантах.

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

make-figures.py скрипта, который измеряет производительность и строит графики. Пример.

Чтобы нарисовать время выполнения функций для разных вводов:

#!/usr/bin/env python
#file: plot_daedra.py
import random
def seq_range(n):
    return list(range(n))
def seq_random(n):
    L = seq_range(n)
    random.shuffle(L)
    return L
if __name__ == '__main__':
    import sys
    from subprocess import check_call
    import daedra
    from reporttime import get_functions_with_prefix
    # measure performance and plot it
    check_call(["make-figures.py"] + [
        "--sort-function=daedra." + f.__name__
        for f in get_functions_with_prefix('sorted_', module=daedra)
    ] + [
        "--sequence-creator=plot_daedra.
 
 " + f.__name__
        for f in get_functions_with_prefix('seq_')
    ] + sys.argv[1:])

seq_range(), seq_random() задают два типа ввода (уже отсортированный и случайный соответственно). Можно определить дополнительные типы, определив seq_*(n) функцию. Пример запуска:

$ PYTHONPATH=. python plot_daedra.py --maxn 1024

PYTHONPATH=. используется, чтобы make-figures.py смог найти plot_daedra модуль (с seq_range, seq_random функциями) в текущей директории. --maxn

определяет наибольшее n, которое в seq_(n) функции передаётся.

Результаты

Рисунки подтверждают, что sorted_insertion() показывает линейное поведение на отсортированном вводе (seq_range=0,1,2,3,4,…,n-1). И квадратичное на случайном вводе (seq_random). Коэффициент перед log2(N) показывает приближённо соответствующую степень в функции роста алгоритма в зависимости от размера ввода:

|------------------------------+-------------------|
| Fitting polynom              | Function          |
|------------------------------+-------------------|
| 1.
 
 00  log2(N)   +  1.25e-015 | N                 |
| 2.00  log2(N)   +  5.31e-018 | N*N               |
| 1.19  log2(N)   +      1.116 | N*log2(N)         |
| 1.37  log2(N)   +      2.232 | N*log2(N)*log2(N) |

Собрав результаты измерений времени выполнения функций сортировки из daedra.py (sorted_*()) для разных типов (уже отсортированный/случайный) и размеров ввода (длины от 1 до 100000):

import random
import daedra
from reporttime import get_functions_with_prefix, measure_func
times = {}  # (function name, input type, exp size) -> time it takes
for f in get_functions_with_prefix('sorted_', module=daedra):
    for N in range(6):
        for case, L in [
            ("range", list(range(10**N))),
            ("random", list(range(10**N)))]:
            if case == "random":
               random.shuffle(L)
            times[(f.__name__, case, N)] = measure_func(f, [L])

Удобно исследовать результаты интерактивно, используя pandas.DataFrame:

import pandas as pd
df = pd. DataFrame([dict(function=f, input=i, size=10**n, time=t)
                   for (f,i,n), t in times.items()])

К примеру, чтобы сравнить поведение функций на уже отсортированном вводе:

def plot_input(input):
    p = df[df.input==input].pivot(index='function', columns='size', values='time')
    p.T.plot(loglog=True,, title=input)  # same style as in @MaxU's answer
    return p
plot_input('range')

Поведение на случайном вводе:

plot_input('random')

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

p = df[df.function=='sorted_insertion'].pivot(index='input', columns='size', values='time')
p.T.plot(loglog=True,, title='sorted_insertion')

соответствующий jupyter notebook.

Python — расчет времени выполнения

Теги:  Использование функции

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

Есть много способов рассчитать время выполнения программы на Python.

Как правило, существует три способа вычисления времени выполнения программы на Python или блока кода.

  • Способ первый
import datetime
start = datetime.datetime.now()
run_function():
    # do something
end = datetime.datetime.now()
print('totally time is ' end - start)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Способ второй:

import time
start = time.time()
run_function()
end = time.time()
print (str(end))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

Метод третий:

import time
start = time.clock()
run_function()
end = time.clock()
print (str(end-start))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

  • Сравнивая вышеуказанные методы, можно обнаружить, что точность метода 2 относительно высока. Первый метод — это, в основном, связь между производительностью и системой, такой как кристалл, бит. Как правило, метод 2 и метод 3 рекомендуются. Метод 2 показывает время UTC. Точность time.time () очень низкая во многих системах, включая windows.

  • Руководство по стандартной библиотеке Python рекомендует максимально использовать time.clock () в любой ситуации, но эта функция возвращает реальное время (время стены) под окнами

  • И метод 1, и метод 2 включают время, когда другие программы используют ЦП. Метод три только вычисляет время процессора программы.

  • И метод два, и метод три возвращают числа с плавающей точкой

Так кто же точнее, time.clock () и time.time ()? С сомнением я проверил документацию модуля времени Python, где метод clock () имеет такое объяснение (из официальной документации)

Time.clock () возвращает время процессора, и из-за jiffy в Unix точность не будет слишком высокой. Часы превращаются в секунды, разделенные на 1000000.

Использовать ли time.clock () с высокой точностью или time. time () с большей точностью, зависит от платформы. В целом, в системах Unix рекомендуется использовать time.time (), а в системах Windows — time.clock ().

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

import timeit
start = timeit.default_timer()
do_func()
end = timeit.default_timer()
print str(end-start)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

[1]http://www.cnblogs.com/youxin/p/3157099.html
[2]http://coreygoldberg.blogspot.hk/2008/09/python-timing-timeclock-vs-timetime.html
[3]http://www.cnblogs.com/moinmoin/archive/2011/03/18/python-runtime-measuring.html
[4]http://www.cnblogs.com/BeginMan/p/3178223.html
[5]http://blog.sina.com.cn/s/blog_56d8ea900100xzg3.html

Интеллектуальная рекомендация

VC Non-ASCII Язык Скопируйте в буфер обмена

MFC версия На сегодняшний день я столкнулся с странным явлением, и японская система нажала Ctrl + C на элементе управления, а затем вставила его, чтобы побраться. Невозможно переключиться на метод япо…

Используйте модуль PHP в HTTPD для анализа веб -страницы PHP

Добавить анализ PHP в файл конфигурации HTTPD Измените файл конфигурации Apache, чтобы Apache мог использовать PHP для анализа Файл конфигурации httpd находится на пути /SR/Local/httpd/conf/httpd.conf…

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

Описание проблемы: Вовлеченные объекты: производители (производственные данные), потребители (потребительские данные), буфер (посредник) Конкретное описание: Производители и потребители представляют с…

[Проблема] Несколько методов дедупликации массивов

1. Установите с помощью оператора раскрытия, чтобы удалить дублирование (лично считаю наиболее лаконичным) 2. метод дедупликации indexOf () 3.includes () метод дедупликации 4. Оптимизируйте метод масс…

Использование апплета WeChat wx: для

Я видел в официальном документе, что wx: for помещается в список рендеринга. Из этого мы можем приблизительно узнать, что основная функция wx: for — это список. Обычно мы говорим список. Я думаю, что …

Вам также может понравиться

Чтение пути Java

…

ofo запускает «торговый центр со скидками». Пользователи, которые не вернули свои депозиты, могут обменять золотые монеты на выгодные покупки.

[TechWeb] Недавно в официальном приложении ofo была запущена функция «Discount Mall». Пользователи, которые еще не реализовали возврат депозита, могут обменять их по соотношению «1 ю…

RadioButton

Radio buttons are normally used together in a RadioGroup Добавить Radiobutton (по крайней мере два) в радиогруппе Добавьте слушатель на объект, реализуйте интерфейс OnCheckedChangeListener (выберите о…

«С помощью логики Java программы, чтобы понять» первая сводная глава

слово： общественности статической общественности статическойпустотаглавная главнаякласс класс Выход Система из проблемных вопросов, линия печать печать линии Что такое программа? Программу можно рассм…

BZOJ2212: [Poi2011] Вращения деревьев (Rock Valley P3521)

Сегмент дерева слияния BZOJ тематический портал Портал Затерянной Долины Научился объединять отрезки. Для поддерева, независимо от того, переключено оно или нет, оно не повлияет на другие узлы вне под…

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


  • Ru Python
  • время&nbsppython
  • Как мне получить время выполнения программы Python?

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

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

  • Как перенести эту функцию NetHack на Python?
  • Проверка дневного времени Python
  • time.sleep (x) не работает так, как должно быть?
  • Python: Как преобразовать строку в datetime без знания формата?
  • Гораздо быстрее вычислительное время в Python

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

import time start_time = time.time() main() print("--- %s seconds ---" % (time. time() - start_time))

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

Печать:

--- 0.764891862869 seconds ---

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

import atexit from time import clock def secondsToStr(t): return "%d:%02d:%02d.%03d" % \ reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = "="*40 def log(s, elapsed=None): print line print secondsToStr(clock()), '-', s if elapsed: print "Elapsed time:", elapsed print line print def endlog(): end = clock() elapsed = end-start log("End Program", secondsToStr(elapsed)) def now(): return secondsToStr(clock()) start = clock() atexit.register(endlog) log("Start Program")

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

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

В Linux или UNIX:

time python yourprogram.py

В Windows см. Обсуждение Stackoverflow: как измерить время выполнения команды в командной строке Windows?

import time start_time = time.clock() main() print time.clock() - start_time, "seconds"

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

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

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

$ python -m cProfile euler048.py 1007 function calls in 0.061 CPU seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.061 0.061 <string>:1(<module>) 1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>) 1 0.005 0.005 0.061 0.061 euler048.py:2(<module>) 1 0.000 0.000 0.061 0.061 {execfile} 1 0.002 0.002 0.053 0.053 {map} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects} 1 0.000 0.000 0.000 0.000 {range} 1 0.003 0.003 0.003 0.003 {sum}

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

#python3 import atexit from time import time from datetime import timedelta def secondsToStr(t): return str(timedelta(seconds=t)) line = "="*40 def log(s, elapsed=None): print(line) print(secondsToStr(time()), '-', s) if elapsed: print("Elapsed time:", elapsed) print(line) print() def endlog(): end = time() elapsed = end-start log("End Program", secondsToStr(elapsed)) def now(): return secondsToStr(time()) start = time() atexit. register(endlog) log("Start Program")

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

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

Например:

from datetime import datetime start_time = datetime.now() # do your work here end_time = datetime.now() print('Duration: {}'.format(end_time - start_time))

Пример вывода, например

Duration: 0:00:08.309267

или

Duration: 1 day, 1:51:24.269711

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

import time from datetime import timedelta start_time = time.monotonic() end_time = time.monotonic() print(timedelta(seconds=end_time - start_time))

Еще лучше для Linux: /usr/bin/time

$ /usr/bin/time -v python rhtest2. py Command being timed: "python rhtest2.py" User time (seconds): 4.13 System time (seconds): 0.07 Percent of CPU this job got: 91% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 0 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 15 Minor (reclaiming a frame) page faults: 5095 Voluntary context switches: 27 Involuntary context switches: 279 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0

Как правило, просто time – это более простая оболочка, которая затеняет более способную /usr/bin/time .

Решение rogeriopvl отлично работает, но если вы хотите получить более конкретную информацию, вы можете использовать встроенный профилировщик python. Проверьте эту страницу:

http://docs.python.org/library/profile.html

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

from time import time start_time = time() ... end_time = time() time_taken = end_time - start_time # time_taken is in seconds hours, rest = divmod(time_taken,3600) minutes, seconds = divmod(rest, 60)

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

$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"

Он запускает 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 to timeit выше, если вы хотите использовать тот же таймер, что и модуль profile .

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

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

def foo(): %run bar.py timeit foo()

time.clock ()

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

time.perf_counter ()

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

time.process_time ()

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

start = time.process_time() ... do something elapsed = (time.process_time() - start)

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

import time from datetime import timedelta start_time = time.time() # # Perform lots of computations. # elapsed_time_secs = time.time() - start_time print "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

Мне тоже нравится ответ Пола МакГира и придумал форму менеджера контекста, которая соответствовала моим потребностям.

import datetime as dt import timeit class TimingManager(object): """Context Manager used with the statement 'with' to time some execution.  Example: with TimingManager() as t: # Code to time """ clock = timeit.default_timer def __enter__(self): """ """ self.start = self.clock() self.log('\n=> Start Timing: {}') return self def __exit__(self, exc_type, exc_val, exc_tb): """ """ self.endlog() return False def log(self, s, elapsed=None): """Log current time and elapsed time if present. :param s: Text to display, use '{}' to format the text with the current time. :param elapsed: Elapsed time to display. Dafault: None, no display. """ print s.format(self._secondsToStr(self.clock())) if(elapsed is not None): print 'Elapsed time: {}\n'.format(elapsed) def endlog(self): """Log time for the end of execution with elapsed time. """ self.log('=> End Timing: {}', self.now()) def now(self): """Return current elapsed time as hh:mm:ss string. :return: String. """ return str(dt.timedelta(seconds = self.clock() - self.start)) def _secondsToStr(self, sec): """Convert timestamp to h:mm:ss string. :param sec: Timestamp. """ return str(dt. datetime.fromtimestamp(sec))

Существует модуль timeit который может использоваться для временного времени выполнения питонных кодов. Он содержит подробную документацию и примеры в документах python ( https://docs.python.org/2/library/timeit.html )

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

import atexit from time import clock def reduce(function, iterable, initializer=None): it = iter(iterable) if initializer is None: value = next(it) else: value = initializer for element in it: value = function(value, element) return value def secondsToStr(t): return "%d:%02d:%02d.%03d" % \ reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = "="*40 def log(s, elapsed=None): print (line) print (secondsToStr(clock()), '-', s) if elapsed: print ("Elapsed time:", elapsed) print (line) def endlog(): end = clock() elapsed = end-start log("End Program", secondsToStr(elapsed)) def now(): return secondsToStr(clock()) def main(): start = clock() atexit. register(endlog) log("Start Program")

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

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

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

from datetime import timedelta from monotonic import monotonic start_time = monotonic() end_time = monotonic() print(timedelta(seconds=end_time - start_time))

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

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

Это объясняется тем, что наиболее эффективным способом является «Порядок роста» и выучить примечание «О», чтобы сделать это правильно, https://en. wikipedia.org/wiki/Big_O_notation

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

import time now = time.time() future = now + 10 step = 4 # why 4 steps? because until here already 4 operations executed while time.time() < future: step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement print(str(int(step / 10)) + " steps per second")

Надеюсь, это поможет вам.

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

import timeit start = timeit.default_timer() #ALL THE PROGRAM STATEMETNS stop = timeit.default_timer() execution_time = stop - start print("Program Executed in "+execution_time) #It returns time in sec

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

def sample_function(start,**kwargs): try: #your statements Except: #Except Statements stop = timeit.default_timer() execution_time = stop - start print("Program Executed in "+execution_time)
  • Удаление элемента из списка – во время итерации – что случилось с этой идиомой?
  • Какие ограничения имеют ограничения в Python по сравнению с закрытием языка X?
  • Вопросы времени и времени, в то время как предсказание временных рядов в Pandas
  • TypeError: объект ‘datetime.datetime’ не может быть вызван
  • Как получить текущее время в Python
  • Функции синхронизации
  • Почему существуют различия в Python time.time () и time.clock () в Mac OS X?
  • Получать длительность теста единицы python в секундах
  • Возможно ли, чтобы в течение двух-трех минут с помощью Mktime Python завершился с ошибкой «вне диапазона»?
  • Доступ к значениям datetime. now () в Python
  • Как получить min, seconds и milliseconds из datetime.now () в python?

Как ограничить время выполнения функции python

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

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

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

Итак, ваш код будет выглядеть примерно так.

Улучшение ответа @rik.the.vik будет заключаться в использовании инструкции with , чтобы дать функции тайм-аута синтаксического сахара:

Здесь используется способ Linux/OSX для ограничения времени работы функции. Это на случай, если вы не хотите использовать потоки и хотите, чтобы ваша программа дождалась окончания функции или истечет срок.

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

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

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

Обратите внимание, что это не прерывает ничего при выполнении собственного кода; он только прервет его, когда функция вернется, поэтому это может не помочь этому конкретному случаю. (Сам SIGALRM может прервать вызов, который блокирует — но код сокета обычно просто повторяет попытку после EINTR.)

Выполнение этого с помощью потоков — лучшая идея, поскольку она более портативна, чем сигналы. Поскольку вы начинаете рабочий поток и блокируете его до тех пор, пока он не завершится, нет никаких обычных concurrency проблем. К сожалению, не существует возможности для асинхронного предоставления исключения в другой поток в Python (это могут использовать другие API-интерфейсы потоков). Он также будет иметь ту же проблему с отправкой исключения во время обработчика исключений и требует того же исправления.

Я предпочитаю подход контекстного менеджера, потому что он позволяет выполнять несколько операторов python внутри оператора with time_limit . Поскольку в системе Windows нет SIGALARM , более переносимый и, возможно, более простой метод может использовать Timer

Ключевым моментом здесь является использование _thread.interrupt_main для прерывания основного потока из потока таймера. Одно из предостережений состоит в том, что основная нить не всегда реагирует на KeyboardInterrupt , поднятый Timer быстро. Например, time.sleep() вызывает системную функцию, поэтому KeyboardInterrupt будет обрабатываться после вызова sleep .

Единственным «безопасным» способом сделать это на любом языке является использование вторичного процесса для выполнения этого тайм-аута, в противном случае вам нужно создать свой код таким образом, чтобы он безопасно выполнял время самостоятельно, например, путем проверки времени, прошедшего в цикле или аналогичном. Если изменение метода не является вариантом, поток будет недостаточным.

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

Итак, посмотрите на процесс, не смотрите на поток.

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

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

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

Если мы хотим задержать выполнение функции на определенное время, мы можем использовать класс python timer. start() и cancel () &#8211; это два его метода.

  • Автор записи

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

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

Python Timer-это класс/библиотека для управления временной сложностью вашего кода. Используя несколько временных модулей, вы можете создать систему в своем коде, чтобы проверить время, затраченное соответствующим фрагментом кода. Существуют различные типы реализаций таймера в python в соответствии с потребностями пользователя, а именно функция таймера python (для проверки времени выполнения скрипта), таймер потоковой передачи python (для проверки времени, затраченного потоком на завершение), таймер обратного отсчета python (создание таймера обратного отсчета) и базовый модуль времени python (для помощи в других действиях).

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

Основные Функции Таймера Python

Самый важный модуль в python относительно времени-это href=&#8221;https://docs.python.org/3/library/time.html&#8221;>время. Этот модуль содержит все основные функции для проверки времени и его анализа. Этот анализ поможет вам понять производительность вашего кода и его эффективность. Мы рассмотрим каждую из важных функций этого модуля вместе с примерами. href=&#8221;https://docs.python.org/3/library/time.html&#8221;>время. Этот модуль содержит все основные функции для проверки времени и его анализа. Этот анализ поможет вам понять производительность вашего кода и его эффективность. Мы рассмотрим каждую из важных функций этого модуля вместе с примерами.

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

  • time.time()
  • time.thread_time()
  • time.process_time()
  • time.perf_counter()
  • time.monotonic()
Функция time.time

time.time() возвращает время в секундах (float) после эпохи. Как правило, эпоха устанавливается на январь 1, 1970, 00:00:00 (UTC), и возвращается количество секунд после этой эпохи. Эта функция зависит от времени компьютера для вычисления количества секунд. Если вы измените компьютерное время между выполнением python, вы можете получить странные числа, используя эту функцию.

Во-первых, мы начинаем с импорта модуля времени. Этот модуль содержит все основные функции времени, которые мы будем использовать в этом разделе. В начале кода мы объявим переменную start как time.time(). Это сохранит текущее время процессора в float number из эпохи. Мы будем использовать эту начальную переменную в качестве ориентира для измерения времени. Следующая часть содержит все коды, которые вы хотите использовать (В этом примере мы использовали циклы for). Аналогично, запишите время окончания работы процессора (время по умолчанию) и проверьте общее время выполнения с помощью end – start.

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

Функциональное время.Thread_time

time.thread_time() возвращает сумму системного и процессорного времени (float) в текущем запущенном потоке. Более того, он не включает в себя время, которое вы проводите в функции time.sleep(). Поскольку функция зависит от потока, вы можете использовать эту функцию для записи временных различий до тех пор, пока ссылки на время принадлежат одному и тому же потоку.

Поскольку thread_time возвращает специфичное для потока время, мы должны убедиться, что используем ссылки в том же потоке . Для этого мы создали экземпляр потока функции &#8216;hello&#8217; и рассчитали время, затраченное потоком внутри него. Однако убедитесь, что вы не можете получить текущее время, вызвав thread_time() , поскольку он возвращает дробное значение.Но вы определенно можете проверить разницу между двумя последовательными ссылками, если они принадлежат одному потоку.

Функциональное время.Process_time

time.process_time() возвращает ссылку на время в дробных секундах (float) суммы системного времени и процессорного времени текущего прогресса. Как и thread_time, эта функция не измеряет время, проведенное в функции time.sleep(). Более того, эта функция создает ссылку на основе процесса. As в результате этого будет иметь смысл только разница во времени между двумя последовательными ссылками.

Мы начинаем с импорта функции process_time и записываем время начала и окончания между кодом. Единственное различие между устаревшими time.time() и time.process_time() заключается в том, что processing time записывает временные ссылки текущего процесса, тогда как time() записывает абсолютное время системы.

Время работы.
Perf_counter

Perf Counter расшифровывается как Performance Counter. Эта функция возвращает значение с высоким разрешением времени, которое является действительным в течение короткого периода времени. Эта функция используется для получения точного отсчета времени между двумя ссылками. Поскольку другие функции таймера python не включают время сна, perf_counter также не включает его. Давайте перейдем к примеру –

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

Функция времени.монотонная

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

Сначала мы импортируем монотонную функцию из модуля времени. Затем создайте две ссылки с именами start и end в верхней и нижней части кода. Это позволит измерить время между двумя ссылками и избежать всех внешних изменений системного времени.

Пользовательские Классы таймера Python

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

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

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

  1. start – (Необязательно) Чтобы запустить таймер.
  2. log – Регистрировать текущее прошедшее время относительно времени начала.
  3. milestone – Сбросить таймер и начать его отсчет с 0.

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

Таймер Python с использованием потоковой передачи

Когда мы хотим выполнить какую-то операцию или хотим, чтобы наша функция выполнялась через определенное время, мы используем класс Python Timer. Класс timer является подклассом класса threading. Технически можно сказать, что мы создаем объекты таймера, когда хотим, чтобы действия (функции) были ограничены временем.

Например, предположим, что мы хотим организовать викторину, где участник должен ответить на каждый вопрос за 10 секунд. Здесь мы можем создать таймер, который будет работать в фоновом режиме, а тем временем участник будет думать над ответом. Теперь давайте разберемся, как создать объект timer .

Синтаксис класса Timer в Python

Если вы не поняли, что делает класс Timer, вы можете думать об этом следующим образом – Класс Timer вызывает функцию через заданное количество секунд.

Чтобы запустить таймер, нам нужно вызвать start()(как и обычные потоки), а чтобы остановить таймер, пока он все еще находится в фоновом режиме, мы можем вызвать cancel().

Чтобы использовать класс Timer, нам нужно импортировать класс threading

Параметры-

Интервал– Время (в секундах), которое вы хотите подождать перед вызовом следующей функции. Он может быть либо в float, либо в integer. Например, в течение 3 секунд.

Функция – Функция, которую вы хотите вызвать через указанный промежуток времени.

Распространенным способом описания параметров *args и **kwargs является- создание объекта таймера, который запускает функцию с аргументами&#8217; args&#8217; и аргументами ключевых слов&#8217; kwargs&#8217; после того, как прошли интервальные секунды. Args должны быть в виде списка и ключевого слова args или kwargs в виде словаря .

Тип возврата-

Он просто вызывает функцию, указанную в параметрах.

Методы в классе Timer
  1. start() – Это означает начало выполнения таймера.
  2. Cancel ()– Во время выполнения таймера мы можем вызвать функцию cancel, если хотим остановить его ().
Создание объекта таймера

<сильный>а. Понимание основ

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

Вы лучше поймете функционирование вышеприведенной программы, когда попытаетесь запустить ее самостоятельно href=&#8221;https://en.wikipedia.org/wiki/System&#8221;>система. href=&#8221;https://en.wikipedia.org/wiki/System&#8221;>система.

<сильный>б. Использование метода отмены

Давайте посмотрим, как использовать функцию cancel() класса Timer.

c. Как использовать параметр &#8216;args&#8217; класса python timer

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

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

Таймер обратного отсчета в python

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

Таймеры Python как контекстные менеджеры

Контекстные менеджеры-это лучший способ избежать ошибок памяти и последующих сбоев. Все должны были знать о &#8220;with&#8221; заявлении в Python. Это утверждение гарантирует, что нам не нужно заботиться о том, чтобы многие объекты закрывались независимо. Каждый мог бы использовать его с комбинацией функций with и open(). Итак, переходя к главному вопросу, можем ли мы создать контекстные менеджеры для таймеров Python?

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

Мы начинаем с создания класса с именем &#8220;Timer_Python pool.&#8221; Затем мы настраиваем операторы, чтобы сделать их полезными в качестве контекстного менеджера. __enter__ функция выполняется в начале контекста, а __exit__ выполняется в конце контекста. Создание точки отсчета между этими двумя функциями может дать вам точное время, необходимое контексту для выполнения.

Python Timer Decorators

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

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

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

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

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

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

Другие Модули Таймера Python

Python содержит тысячи модулей и миллионы фрагментов кода. Мы всегда можем использовать модули с открытым исходным кодом для использования таймеров python. Github-это самое большое место для поиска таких модулей. Давайте сразу перейдем к этим модулям –

  1. term down: Продвинутый таймер python, созданный с использованием различных символов ASCII. Используя этот скрипт, вы можете создать простой таймер обратного отсчета в вашем терминале и выполнить команду в конце. Самое главное, что он имеет поддержку голосового обратного отсчета.
  2. MobTimer.Python: Таймер на основе графического интерфейса, созданный на python. Этот скрипт создает полноэкранные таймеры с несколькими опциями. Наряду с этим, вы можете запускать несколько раз на вашем экране одновременно с помощью этой программы.
  3. timer: Это самый простой таймер на основе графического интерфейса, созданный на python (Tkinter). Такие функции, как несколько таймеров, меток и многопоточность, делают его более жизнеспособным по сравнению с другими программами.
  4. code timing: Этот класс таймера записывает все ваши прошлые времена выполнения для определенного именованного процесса. Вы можете проверить минимальное время, максимальное время, среднее время и среднее время для конкретного процесса вместе с записями. Этот модуль можно использовать несколькими способами, а именно как контекстный менеджер и как декоратор.
  5. cTimer: crime-это таймер с точностью до наносекунды в python. Этот модуль использует API языка c для точной записи времени. Если вы ищете хардкорные модули точной записи времени, то это самый лучший вариант. (Примечание: В последних обновлениях python модуль time добавлен с функциями записи времени в наносекундах)

Должен Читать:

  • Как преобразовать строку в нижний регистр в
  • Как вычислить Квадратный корень
  • Пользовательский ввод | Функция ввода () | Ввод с клавиатуры
  • Лучшая книга для изучения Python

Вывод

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

И последнее, но не менее важное: таймер &#8211; это подкласс класса threading в python. Если мы хотим запустить какую-либо функцию через определенный промежуток времени, мы можем использовать класс python timer. В параметре args, который по умолчанию равен None, мы можем указать аргументы, которые мы хотим передать методу обратного вызова .

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

Как ограничить время выполнения функции и реализовать добавление новых функций

Как ограничить время выполнения функции
Есть функция main, которая вызывает функцию doter. doter должна работать заданное время. Я не.

Как ограничить время выполнения программы?
При выполнении макроса у меня получается(непонятно где) бесконечный цикл. Можно ли просто как-то.

Как ограничить время выполнения программы?
Добрый день! Задали написать программу, следующего содержания: &quot;Для натурального числа сумма.

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

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

Ограничить время выполнения HTTP запроса
Всем привет Имеется код, работающий на отдельном сервисе BufferedReader rdr = null;.

Ограничить время ожидания выполнения TADOQuery.Open
Добрый день, Пишу на Delphi 7, мне нужно сделать чтобы если выполнение TADOQuery продолжается.

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

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

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

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

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

import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time. time() - start_time))

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

принты:

--- 0.764891862869 seconds ---