Як отримати час виконання програми Python?

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

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

Найпростіший спосіб в 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функцію, вона просто формує число з секундами з плаваючою точкою в год: мм: ss.sss.)

Примітка: Версію Python 3 вищевказаного коду можна знайти тут або тут .

У 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

Мені дуже подобається відповідь Пола Макгвайра , але я використовую 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")

Якщо вам це здається корисним, вам слід все-таки проголосувати його відповідь замість цієї, як це робила більша частина роботи;).

import time

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

time.clock()повертає час процесора, що дозволяє обчислити лише час, який використовується цим процесом (все одно на Unix). У документації сказано, "у будь-якому випадку це функція, яка використовується для порівняльного алгоритму Python або алгоритмів синхронізації"

Мені подобається висновок, 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))

Ви можете використовувати профайлер cProfile Python для вимірювання часу процесора та додатково, скільки часу витрачається всередині кожної функції та скільки разів викликається кожна функція. Це дуже корисно, якщо ви хочете покращити продуктивність свого сценарію, не знаючи, з чого почати. Ця відповідь на ще одне запитання про переповнення стека досить хороша. Завжди добре ознайомитися і з документацією .

Ось приклад, як профілювати сценарій за допомогою 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}

Ще краще для 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

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)

Просто використовуйте 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 "+str(execution_time)) # It returns time in seconds

Він повертається за лічені секунди, і ви можете мати час виконання. Це просто, але слід записати їх у головну функцію, яка запускає виконання програми. Якщо ви хочете отримати час виконання, навіть коли ви отримаєте помилку, тоді візьміть до нього свій параметр "Пуск" і обчисліть так:

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 " + str(execution_time))

Наступні відбитки фрагментів минули час у приємному для людини читаному <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)    

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)

У 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?

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

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

Для даних, які використовують Jupyter Notebook

У комірці ви можете використовувати %%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.

Існує timeitмодуль, який може бути використаний для часового часу виконання коду Python.

Вона має детальну документацію та приклади в документації на Python, 26.6. timeit - Виміряйте час виконання невеликих фрагментів коду .

Використовуйте 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 або новішою.

Це відповідь Пола Макгвайра, яка працює на мене. Про всяк випадок, якщо у когось виникли проблеми із запуском цього.

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()Після імпорту файла зателефонуйте зі своєї програми.

Timeit - клас в Python, який використовується для обчислення часу виконання невеликих блоків коду.

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

Зразок коду такий:

from timeit import default_timer as timer

start= timer()

# Some logic

end = timer()

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

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

Час виконання програми 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")

Ви робите це просто в Python. Не потрібно ускладнювати це.

import time

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

Подібно до відповіді від @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

По-перше, встановіть humanfriendly package, відкривши командний рядок (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))

Вихід:

Для використання оновленої відповіді 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))

Я спробував і знайшов різницю у часі, використовуючи наступні сценарії.

import time

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

Якщо ви хочете виміряти час у мікросекундах, тоді ви можете скористатися наступною версією, заснованою повністю на відповідях Пола Макгуайра та Нікьо - це код 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 для реєстрації функцій, які можна викликати, коли програма закінчується.