Как вывести время работы программы в питоне

For the data folks using Jupyter Notebook

In a cell, you can use Jupyter’s %%time magic command to measure the execution time:

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

Output

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

This will only capture the execution time of a particular cell. If you’d like to capture the execution time of the whole notebook (i.e. program), you can create a new notebook in the same directory and in the new notebook execute all cells:

Suppose the notebook above is called example_notebook.ipynb. In a new notebook within the same directory:

# 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

Output

IPython CPU timings (estimated):
  User   :       0.00 s.
  System :       0.00 s.
Wall time:       0.00 s.

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)

I’ve looked at the timeit module, but it seems it’s only for small snippets of code. I want to time the whole program.

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

It runs your_module.main() function one time and print the elapsed time using time.time() function as a timer.

To emulate /usr/bin/time in Python see Python subprocess with /usr/bin/time: how to capture timing info but ignore all other output?.

To measure CPU time (e.g., don’t include time during time.sleep()) for each function, you could use profile module (cProfile on Python 2):

$ python3 -mprofile your_module.py

You could pass -p to timeit command above if you want to use the same timer as profile module uses.

See How can you profile a Python script?

answered Mar 3, 2015 at 9:04

I liked Paul McGuire’s answer too and came up with a context manager form which suited my needs more.

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

First, install humanfriendly package by opening Command Prompt (CMD) as administrator and type there —
pip install humanfriendly

Code:

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

Output:

Following this answer created a simple but convenient instrument.

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

Usage:

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

The output:

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

answered Nov 26, 2020 at 13:05

This is Paul McGuire’s answer that works for me. Just in case someone was having trouble running that one.

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

Call timing.main() from your program after importing the file.

The time of a Python program’s execution measure could be inconsistent depending on:

• Same program can be evaluated using different algorithms
• Running time varies between algorithms
• Running time varies between implementations
• Running time varies between computers
• Running time is not predictable based on small inputs

This is because the most effective way is using the «Order of Growth» and learn the Big «O» notation to do it properly.

Anyway, you can try to evaluate the performance of any Python program in specific machine counting steps per second using this simple algorithm:
adapt this to the program you want to evaluate

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

start = time.time()

a = 0

for i in range(1000):

    a += (i**100)

end = time.time()

print("The time of execution of above program is :",

      (end-start) * 10**3, "ms")

import time

for j in range(100, 5501, 100):

    start = time.time()

    a = 0

    for i in range(j):

        a += (i**100)

    end = time.time()

    print(f"Iteration: {j}tTime taken: {(end-start)*10**3:.03f}ms")

from datetime import datetime

start = datetime.now()

a = 0

for i in range(1000):

    a += (i**100)

end = datetime.now()

td = (end - start).total_seconds() * 10**3

print(f"The time of execution of above program is : {td:.03f}ms")

import timeit

mysetup = "from math import sqrt"

mycode =

exec_time = timeit.timeit(stmt=mycode,

                          setup=mysetup,

                          number=1000000) * 10**3

print(f"The time of execution of above program is : {exec_time:.03f}ms")

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

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

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

Печать

--- 0.764891862869 seconds ---

rogeriopvl
13 окт. 2009, в 00:31

Поделиться

Я помещаю этот модуль 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 будет печатать время начала и окончания, а общая истекшая time. (пропустите мою непонятную secondsToStr функцию, она просто форматирует число с плавающей точкой в ​​секундах до hh: mm: ss.sss form.)

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

PaulMcG
13 окт. 2009, в 03:59

Поделиться

import time

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

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

newacct
13 окт. 2009, в 01:44

Поделиться

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

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

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

Nicojo
10 сен. 2012, в 03: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}

jacwah
02 янв. 2014, в 00:56

Поделиться

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

Например:

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

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

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

metakermit
29 сен. 2014, в 13:05

Поделиться

Еще лучше для 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.

u0b34a0f6ae
13 окт. 2009, в 07:28

Поделиться

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

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

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

wezzy
13 окт. 2009, в 01:17

Поделиться

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

Sandeep
02 июль 2016, в 00:08

Поделиться

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)

Qina Yan
06 апр. 2016, в 09:04

Поделиться

<сильный > time.clock()

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

<сильный > time. perf_counter()

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

<сильный > time. process_time()

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

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

Yas
18 май 2016, в 04:26

Поделиться

Ipython «timeit» любой script:

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

ab-user
20 май 2015, в 15:42

Поделиться

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

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

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

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

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

$ python3 -mprofile your_module.py

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

См. Как вы можете profile Python script?

jfs
03 март 2015, в 09:31

Поделиться

Просто используйте 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

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

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)

Ravi Kumar
18 сен. 2017, в 20:17

Поделиться

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

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

Gall
29 янв. 2015, в 15:51

Поделиться

Alfie
20 окт. 2014, в 15:44

Поделиться

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

Yu Jiaao
28 март 2018, в 07:15

Поделиться

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

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

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

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

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

Предположим, что записная книжка выше называется 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 (по оценкам): Пользователь: 0,00 с.
Система: 0,00 с.
Время стены: 0,00 с.

Matt
28 июль 2018, в 17:00

Поделиться

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

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

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

from timeit import default_timer as timer

start= timer()

#some logic 

end = timer() 

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

Utkarsh Dhawan
16 нояб. 2017, в 03:09

Поделиться

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

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

Saurabh Rana
08 апр. 2015, в 00:47

Поделиться

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

H0R5E
16 июнь 2017, в 13:59

Поделиться

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

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 = '33[36m'
    colour_reset = '33[0;0;39m'
    colour_red = '33[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 для регистрации функций, которые вы можете вызывать при выходе из программы.

Rui Carvalho
20 дек. 2018, в 02:13

Поделиться

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

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'

Я чувствую себя немного элегантно в этом смысле.

Tao Wang
07 авг. 2018, в 06:23

Поделиться

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

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

Это связано с тем, что наиболее эффективным способом является использование «Ордена роста» и изучение записи «Большой буквы», чтобы сделать это правильно, 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")

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

Manu
31 июль 2017, в 16:51

Поделиться