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

Следующий фрагмент кода выводит истекшее время в удобном для чтения формате <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)    

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

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

%%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.

Подобно ответу @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

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

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

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

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

Я посмотрел на модуль 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?

Позже ответ, но я использую встроенный 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 аргумент указывает, сколько раз код должен повторяться.
• Демо

Используйте 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))]

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

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'

У меня была такая же проблема во многих местах, поэтому я создал удобный пакет 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 или новее.

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

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

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

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

print("Time taken:", end-start)

Сначала установите пакет humanfriendly, открыв командную строку (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))

Выход:

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

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

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

import time

start = time.localtime()
end = time.localtime()
"""Total execution time in minutes$ """
print(end.tm_min - start.tm_min)
"""Total execution time in seconds$ """
print(end.tm_sec - start.tm_sec)

Я попробовал и нашел разницу во времени, используя следующие сценарии.

import time

start_time = time.perf_counter()
[main code here]
print (time.perf_counter() - start_time, "seconds")

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

def timeit(method):
    def timed(*args, **kw):
        ts = time.time()
        result = method(*args, **kw)
        te = time.time()
        if 'log_time' in kw:
            name = kw.get('log_name', method.__name__.upper())
            kw['log_time'][name] = int((te - ts) * 1000)
        else:
            print('%r  %2.22f ms' % (method.__name__, (te - ts) * 1000))
        return result
    return timed

@timeit
def foo():
    do_some_work()


# 'foo'  0.000953 ms

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

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

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

import time
from datetime import timedelta

def start_time_measure(message=None):
    if message:
        print(message)
    return time.monotonic()

def end_time_measure(start_time, print_prefix=None):
    end_time = time.monotonic()
    if print_prefix:
        print(print_prefix + str(timedelta(seconds=end_time - start_time)))
    return end_time

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

total_start_time = start_time_measure()    
start_time = start_time_measure('Doing something...')
# Do something
end_time_measure(start_time, 'Done in: ')
start_time = start_time_measure('Doing something else...')
# Do something else
end_time_measure(start_time, 'Done in: ')
end_time_measure(total_start_time, 'Total time: ')

Выход:

Doing something...
Done in: 0:00:01.218000
Doing something else...
Done in: 0:00:01.313000
Total time: 0:00:02.672000

Время выполнения программы 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")

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

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

import time
print(time.clock())

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

Тогда код будет следующим:

from datetime import timedelta
from monotonic import monotonic

start_time = monotonic()
end_time = monotonic()
print(timedelta(seconds=end_time - start_time))

Если вы хотите измерять время в микросекундах, вы можете использовать следующую версию, полностью основанную на ответах Пола Макгуайра и Nicojo - это код 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 для регистрации функций, которые вы можете вызывать при выходе из программы.

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

import time
start_time = time.perf_counter ()
for x in range(1, 100):
    print(x)
end_time = time.perf_counter ()
print(end_time - start_time, "seconds")