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

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

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

12.10.2009 23:56:47
30 ОТВЕТОВ
РЕШЕНИЕ

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

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

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

Печать:

--- 0.764891862869 seconds ---
1668
15.07.2017 11:44:17
хотя он вычисляет реальное время (включая время, используемое другими программами), поэтому, когда ваш компьютер занят другими
newacct 13.10.2009 01:23:29
в Windows сделайте то же самое, но используйте time.clock () вместо time.time (). Вы получите немного лучшую точность.
Corey Goldberg 13.10.2009 14:02:34
Я рекомендую сделать round(time.time() - start_time, 2)(или любое другое десятичное число, которое вы хотите), я вернул научные цифры, такие как 1.24e-5.
ThorSummoner 6.02.2015 17:49:28
@ThorSummoner: вы, вероятно, хотите '%.2f'вместо round()здесь.
jfs 3.03.2015 08:41:06
В этом методе есть большой недостаток. Если системное время изменяется во время работы программы (например, синхронизация с сервером времени), тогда этот метод не будет работать или даже может нарушить код (отрицательная продолжительность ...)
Gilad 9.11.2016 15:53:25

В Linux или Unix:

$ time python yourprogram.py

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

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

$ time -v python yourprogram.py
    Command being timed: "python3 yourprogram.py"
    User time (seconds): 0.08
    System time (seconds): 0.02
    Percent of CPU this job got: 98%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10
    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): 9480
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 1114
    Voluntary context switches: 0
    Involuntary context switches: 22
    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
170
23.12.2019 17:57:12
так что, если я запускаю другой виджет, например, в приложении QT, как мы рассчитываем время, необходимое этому виджету для отображения?
Ciasto piekarz 18.12.2013 16:47:12
Для случая виджета, если вы запускаете программу на Python, используйте принятый ответ rogeriopvl.
steveha 18.12.2013 19:25:30
но это, кажется, не дает времени в мин: секунды это заканчивается плавающее число!
Ciasto piekarz 19.12.2013 05:48:28
Да, это дает количество секунд. Вы можете конвертировать в мин: секунды, если хотите. Посмотрите на ответ Пола Макгуайра и его secondsToStr()функции.
steveha 19.12.2013 06:48:29
import time

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

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

66
16.03.2015 17:16:44
time.time () лучше всего использовать на * nix. time.clock () лучше всего использовать в Windows.
Corey Goldberg 13.10.2009 14:03:50
Я считаю, что это не может быть использовано для расчета «только время, используемое этим процессом», потому что он использует системное время и будет зависеть от других системных процессов? Поправьте меня, если я ошибаюсь по этому поводу :)
AnnanFay 23.07.2013 10:49:48
Примечание: time.clock () является "Устаревшим с версии 3.3: поведение этой функции зависит от платформы: используйте perf_counter () [с временем ожидания] или process_time () [без времени ожидания] вместо этого, в зависимости от ваших требований, чтобы иметь четко определенное поведение. "
mab 19.10.2015 13:14:24

Я помещаю этот 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функцию, она просто форматирует число с плавающей точкой в ​​чч: мм: сс.ссс.)

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

206
23.05.2017 12:26:37
Это действительно чистое решение, которое также работает, если вы нажмете Ctrl-C, чтобы остановить программу.
sorin 9.06.2010 14:31:04
отличное решение, я определенно буду его использовать и создам декоратор синхронизации для определения функций узкого места
c24b 15.05.2014 22:32:10
Для Python 3 добавьте from functools import reduceсверху и поставьте квадратные скобки вокруг каждого оператора печати. Работает отлично!
PowerApp101 5.04.2015 02:02:14
@ PowerApp101 - Спасибо. В ответе Nicojo приведена версия этого модуля для Py3.
PaulMcG 5.04.2015 04:21:31
Примечание: time.clock () является "Устаревшим с версии 3.3: поведение этой функции зависит от платформы: используйте perf_counter () [с временем ожидания] или process_time () [без времени ожидания] вместо этого, в зависимости от ваших требований, чтобы иметь четко определенное поведение. "
mab 19.10.2015 13:12:53

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

$ 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
27
23.12.2019 19:16:43

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

#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta

def secondsToStr(elapsed=None):
    if elapsed is None:
        return strftime("%Y-%m-%d %H:%M:%S", localtime())
    else:
        return str(timedelta(seconds=elapsed))

def log(s, elapsed=None):
    line = "="*40
    print(line)
    print(secondsToStr(), '-', s)
    if elapsed:
        print("Elapsed time:", elapsed)
    print(line)
    print()

def endlog():
    end = time()
    elapsed = end-start
    log("End Program", secondsToStr(elapsed))

start = time()
atexit.register(endlog)
log("Start Program")

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

65
23.09.2019 08:59:27
Я нашел timedelta(seconds=t).total_seconds()полезным.
nu everest 28.11.2015 12:38:47
Можете ли вы объяснить, что делают эти функции? что есть в команде log? что такое атексит?
SumNeuron 10.12.2016 16:35:11
@SumNeuron, короче говоря, эти функции выводят время выполнения программы, с которой вы его используете. s является первым аргументом для регистрации, и должен быть строкой. Журнал - это функция, которая выводит информацию о времени. atexit - это модуль Python, который позволяет регистрировать функции, вызываемые при выходе из программы.
Nicojo 10.12.2016 21:07:49
@Nicojo Очень полезно. У меня есть вопрос о том, как я могу использовать этот код, чтобы проверить, например, время выполнения цикла. Предположим, у меня есть функция, включающая цикл, и я хочу получить время, потраченное на этот цикл
moudi 13.06.2019 18:48:09
@moudi Лучший ответ на этот вопрос - ваш лучший выбор. Просто установите время начала непосредственно перед началом цикла и рассчитайте истекшее время на выходе из цикла.
Nicojo 14.06.2019 19:08:47

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

Вот пример того, как профилировать скрипт, используя 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}
52
27.11.2019 17:38:06
@jacwah Как вы оцениваете общее время?
Chuck 3.11.2018 21:11:44
@ Чак Первая строка говорит X function calls in Y CPU seconds. Если вам нужно время на настенных часах, используйте один из других ответов здесь.
jacwah 5.11.2018 18:52:35

Мне нравится вывод, который 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))
51
27.11.2019 17:39:21
@phansen: вы можете использовать timedelta(seconds=time.monotonic()-start)здесь (или, time.time()если интервал большой). Не вычитайте наивные объекты даты и времени, которые представляют местное время; Местное время не однообразно
jfs 3.03.2015 08:31:02
ОК, ты имеешь в виду, как start_time = time.monotonic(); end_time = time.monotonic(); timedelta(seconds=end_time - start_time). Я верю, что вы правы, но вы также должны отформатировать его, когда вернетесь datetime.timedelta(0, 0, 76). Кроме того, кажется, что монотонный метод был добавлен только в Python 3.
metakermit 4.03.2015 10:23:44
Ах хорошо. Я вижу, вы можете передать это, str()чтобы сделать это "человеком". Я обновлю ответ, спасибо.
metakermit 4.03.2015 10:24:47

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

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

5
27.11.2019 17:42:17
ОП прямо упоминает timeitв вопросе. Вопрос в том, как это можно использовать здесь (или следует использовать здесь и каковы альтернативы). Вот возможный ответ .
jfs 3.03.2015 09:06:42

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

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))
7
27.11.2019 17:45:15

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

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

8
28.11.2019 08:47:28

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

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()из вашей программы после импорта файла.

3
27.11.2019 17:45:48

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

def foo():
    %run bar.py
timeit foo()
7
27.11.2019 17:54:31
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)
7
6.04.2016 07:48:25

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)
18
18.05.2016 03:49:41
Возможно, начните с вывода «Использовать time.process_time ()» (или подобное)?
Peter Mortensen 27.11.2019 17:56:11

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

import time
from datetime import timedelta

start_time = time.time()

#
# Perform lots of computations.
#

elapsed_time_secs = time.time() - start_time

msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))

print(msg)    
12
20.02.2018 12:19:21
Здесь вы найдете наиболее разумный ответ («здравый смысл» означает максимально полагаться на встроенные модули и, следовательно, наименьшее количество печатать).
ijoseph 20.07.2017 17:25:32

Чтобы использовать обновленный ответ 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))
1
27.11.2019 17:58:53

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

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

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

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

import time

now = time.time()
future = now + 10
step = 4 # Why 4 steps? Because until here already four operations executed
while time.time() < future:
    step += 3 # Why 3 again? Because a while loop executes one comparison and one plus equal statement
step += 4 # Why 3 more? Because one comparison starting while when time is over plus the final assignment of step + 1 and print statement
print(str(int(step / 10)) + " steps per second")
1
27.11.2019 18:01:27

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

import timeit

start = timeit.default_timer()

# All the program statements
stop = timeit.default_timer()
execution_time = stop - start

print("Program Executed in "+execution_time) # It returns time in seconds

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

def sample_function(start,**kwargs):
     try:
         # Your statements
     except:
         # except statements run when your statements raise an exception
         stop = timeit.default_timer()
         execution_time = stop - start
         print("Program executed in " + execution_time)
16
30.01.2020 12:34:16

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

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

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

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)
3
27.11.2019 18:06:01
timeitэто лучший ответ IMO для многих случаев.
Marc 4.12.2019 20:10:11

Используйте line_profiler .

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

from line_profiler import LineProfiler
import random

def do_stuff(numbers):
    s = sum(numbers)
    l = [numbers[i]/43 for i in range(len(numbers))]
    m = ['hello'+str(numbers[i]) for i in range(len(numbers))]

numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()

Результаты будут:

Timer unit: 1e-06 s

Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     4                                           def do_stuff(numbers):
     5         1           10     10.0      1.5      s = sum(numbers)
     6         1          186    186.0     28.7      l = [numbers[i]/43 for i in range(len(numbers))]
     7         1          453    453.0     69.8      m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
5
27.11.2019 18:07:16

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

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

%%time
[ x**2 for x in range(10000)]

Вывод

CPU times: user 4.54 ms, sys: 0 ns, total: 4.54 ms
Wall time: 4.12 ms

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

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

# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb

# Run the example_notebook with -t flag for time
%run -t example_notebook

Вывод

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.
6
27.11.2019 18:08:49

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

import time
def timing():
    start_time = time.time()
    return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))

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

t = timing()
train = pd.read_csv('train.csv',
                        dtype={
                            'id': str,
                            'vendor_id': str,
                            'pickup_datetime': str,
                            'dropoff_datetime': str,
                            'passenger_count': int,
                            'pickup_longitude': np.float64,
                            'pickup_latitude': np.float64,
                            'dropoff_longitude': np.float64,
                            'dropoff_latitude': np.float64,
                            'store_and_fwd_flag': str,
                            'trip_duration': int,
                        },
                        parse_dates = ['pickup_datetime', 'dropoff_datetime'],
                   )
t("Loaded {} rows data from 'train'".format(len(train)))

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

[9.35s] Loaded 1458644 rows data from 'train'
5
27.11.2019 18:13:39

Если вы хотите измерять время в микросекундах, то вы можете использовать следующую версию, полностью основанную на ответах Пола Макгуайра и Никохо - это код Python 3. Я также добавил немного цвета к нему:

import atexit
from time import time
from datetime import timedelta, datetime


def seconds_to_str(elapsed=None):
    if elapsed is None:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
    else:
        return str(timedelta(seconds=elapsed))


def log(txt, elapsed=None):
    colour_cyan = '\033[36m'
    colour_reset = '\033[0;0;39m'
    colour_red = '\033[31m'
    print('\n ' + colour_cyan + '  [TIMING]> [' + seconds_to_str() + '] ----> ' + txt + '\n' + colour_reset)
    if elapsed:
        print("\n " + colour_red + " [TIMING]> Elapsed time ==> " + elapsed + "\n" + colour_reset)


def end_log():
    end = time()
    elapsed = end-start
    log("End Program", seconds_to_str(elapsed))


start = time()
atexit.register(end_log)
log("Start Program")

log () => функция, которая печатает информацию о времени.

txt ==> первый аргумент в логе и его строка для отметки времени.

atexit ==> Модуль Python для регистрации функций, которые вы можете вызывать при выходе из программы.

0
27.11.2019 18:17:18

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

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)
2
27.11.2019 18:18:21

Это самый простой способ получить истекшее время для программы:

Напишите следующий код в конце вашей программы.

import time
print(time.clock())
0
27.11.2019 18:26:20
main : 1: DeprecationWarning: time.clock устарел в Python 3.3 и будет удален из Python 3.8: используйте вместо этого time.perf_counter или time.process_time
JayRizzo 5.07.2019 16:20:49

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

from horology import Timing

with Timing(name='Important calculations: '):
    prepare()
    do_your_stuff()
    finish_sth()

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

Important calculations: 12.43 ms

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

from horology import timed

@timed
def main():
    ...

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

main: 7.12 h

Он заботится о единицах и округлениях. Он работает с Python 3.6 или новее.

5
7.12.2019 22:05:27
Спасибо, что поделились!
Darren Zou 10.12.2019 18:28:21
@DarrenZou проверить больше документы и источники здесь
hans 11.12.2019 20:27:40
Могу ли я получить эти значения в переменной?
PepeElMago33 15.02.2020 22:34:40
Да, используйте main.interval.
hans 15.02.2020 22:47:37

Позже отвечу, но я использую timeit:

import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
    b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=500)
print(elapsed_time)
# 10.159821493085474

  • Оберните весь свой код, включая любые импортируемые вами, внутри code_to_test.
  • number Аргумент указывает количество повторений кода.
  • демонстрация
2
25.02.2020 01:02:14
А что, если вы хотите рассчитать какой-то фрагмент кода, который нельзя поместить в строку?
Daniel 22.04.2020 11:26:32

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

import time
start_time = time.time()
main()
seconds = time.time() - start_time
print('Time Taken:', time.strftime("%H:%M:%S",time.gmtime(seconds)))

Пример вывода

Time Taken: 00:00:08
2
12.03.2020 05:27:12

Во-первых, установите удобный для пользователя пакет, открыв командную строку (CMD) от имени администратора, и введите там - pip install humanfriendly

Код:

from humanfriendly import format_timespan
import time
begin_time = time.time()
# Put your code here
end_time = time.time() - begin_time
print("Total execution time: ", format_timespan(end_time))

Вывод:

введите описание изображения здесь

1
16.04.2020 11:49:08