Python Время выполнения — это средство измерения времени выполнения небольших фрагментов кода, его имеет смысл применять при оптимизации программы.
Измерение времени выполнения фрагментов кода
Модуль timeit позволяет измерить время выполнения небольших фрагментов кода с целью оптимизации программы. Прежде чем использовать модуль, необходимо подключить его с помощью инструкции:
from timeit import Timer
Измерения производятся с помощью класса Timer. Конструктор класса имеет следующий формат:
Timer( [stmt=’pass’] [, setup=’pass’] [, timer=])
В параметре stmt указывается код (в виде строки), для которого измеряем время выполнения. Параметр setup позволяет указать код, который будет выполнен перед измерением времени выполнения кода в параметре stmt.
Например, в параметре setup можно подключить модуль.
Получить время выполнения можно с помощью метода timeit ( [number=1000000]). В параметре number указывается количество повторений. Для примера просуммируем числа от 1 до 10000 тремя сnособами и выведем время выполнения каждого сnособа (листинг 10.4) .
Измерение времени исполнения программы в Python
# Листинг_10.4. Измерение времени выполнения
# -*- coding: utf-8 -*-
from timeit import Timer
code1 = «»»
i, j = 1, 0
while i < 10001:
‘ j += i
‘ i += 1
«»»
t1 = Timer(stmt=code1)
print(«while:», t1.timeit(number=10000))
code2 = «»»
j = 0
for i in range(1, 10001):
‘ j += i
«»»
t2 = Timer(stmt=code2)
print(«for:», t2.timeit(number=10000))
code3 = «»»
j = sum(range(1, 10001))
«»»
t3 = Timer(stmt=code3)
print(«sum:», t3.timeit(number=10000))
input()
Примерный результат выполнения (зависит от мощности компьютера):
while: 17.26802443580117
for: 9.602403053818772
sum: 3.067899091205735
На моём ноутбуке получены такие результаты:
while: 41.55120102917928
for: 23.030579681389646
sum: 7.445543743319618
Как видно из результата, цикл for работает в два раза быстрее цикла while, а функция sum () в данном случае является самым оптимальным решением задачи.
Метод repeat([repeat=3] [, number=1000000]) вызывает метод timeit() указанное количество раз (задается в параметре repeat) и возвращает список значений. Аргумент number передается в качестве параметра методу timeit (). Для примера создадим список со строковыми Представлениями чисел от 1 до 10000. В первом случае для создания списка используем цикл for и метод append (),а во втором- генератор списков (листинг 10.5).
Листинг 10.5. Использование метода repeat()
# -*- coding: utf-8 -*-
from timeit import Timer
code1 = «»»
arr1 = []
for i in range(1, 10001):
‘ arr1.append(str(i))
«»»
t1 = Timer(stmt=code1)
print(«append:», t1.repeat(repeat=3, number=2000))
code2 = «»»
arr2 = [str(i) for i in range(1, 10001)]
Как замерять время выполнения кода в Python | timeit vs time
«»»
t2 = Timer(stmt=code2)
print(«генератор:», t2.repeat(repeat=3, number=2000))
input()
Примерный результат выполнения:
append: [9.98154294362325, 9.997541285814483, 10.004275691347512]
генератор: [7.879446040575054, 7.924527742041953, 7.844603314867392]
На моём ноутбуке получены такие результаты:
append: [27.529709871288585, 26.59919227347495, 24.542013299966086]
генератор: [17.88548844413438, 18.161865323442626, 18.18962500240015]
Как видно из результата, генераторы списков работают быстрее.
Возиться с форматированием результатов не стал, так как повторно измерять результаты не собираюсь.
При отладке программ имеет смысл сначала уменьшить number до 100, чтобы не ждать слишком долго.
Вскоре запущу эти программы на ноутбуке с более быстрым процессором — результаты доложу.
Когда умудрюсь откомпилировать эти программы, смогу выяснить достигнутую прибавку скорости.
Приглашаю всех высказываться в Комментариях. Критику и обмен опытом одобряю и приветствую. В хороших комментариях сохраняю ссылку на сайт автора!
И не забывайте, пожалуйста, нажимать на кнопки социальных сетей, которые расположены под текстом каждой страницы сайта.
Продолжение тут…
Источник: ep-z.ru
Как мне узнать время выполнения программы на Python?
У меня есть программа командной строки на Python, которая требует времени, чтобы закончить. Я хочу знать точное время, необходимое для завершения бега.
Я посмотрел на модуль timeit , но, похоже, он предназначен только для небольших фрагментов кода. Я хочу, чтобы время всей программы.
john2x 13 Окт 2009 в 03:56
27 ответов
Лучший ответ
Самый простой способ в Python:
import time start_time = time.time() main() print(«— %s seconds —» % (time.time() — start_time))
Это предполагает, что вашей программе требуется не менее десятой секунды для запуска.
— 0.764891862869 seconds —
Peter Mortensen 15 Июл 2017 в 11:44
Чтобы использовать обновленный ответ 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))
Peter Mortensen 27 Ноя 2019 в 17:58
Время выполнения программы 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»)
Peter Mortensen 27 Ноя 2019 в 18:01
Timeit — это класс в Python, используемый для вычисления времени выполнения небольших блоков кода.
Default_timer — метод в этом классе, который используется для измерения времени настенных часов, а не времени выполнения ЦП. Таким образом, выполнение другого процесса может помешать этому. Таким образом, это полезно для небольших блоков кода.
Пример кода выглядит следующим образом:
from timeit import default_timer as timer start= timer() # Some logic end = timer() print(«Time taken:», end-start)
Peter Mortensen 27 Ноя 2019 в 18:06
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() из вашей программы после импорта файла.
Peter Mortensen 27 Ноя 2019 в 17:45
Вы делаете это просто в Python. Нет необходимости усложнять.
import time start = time.localtime() end = time.localtime() «»»Total execution time in seconds$ «»» print(end.tm_sec — start.tm_sec)
swateek 29 Сен 2020 в 02:50
Я использовал очень простую функцию для измерения времени выполнения кода:
import time def timing(): start_time = time.time() return lambda x: print(«[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’
Peter Mortensen 27 Ноя 2019 в 18:13
Существует модуль timeit , который можно использовать для определения времени выполнения кода Python.
Он содержит подробную документацию и примеры в документации по Python, 26.6. timeit — измеряет время выполнения небольших фрагментов кода .
Peter Mortensen 27 Ноя 2019 в 17:42
У меня была такая же проблема во многих местах, поэтому я создал удобный пакет horology . Вы можете установить его с помощью pip install horology , а затем сделать это элегантным способом:
from horology import Timing with Timing(name=’Important calculations: ‘): prepare() do_your_stuff() finish_sth()
Important calculations: 12.43 ms
Или даже проще (если у вас есть одна функция):
main: 7.12 h
Он заботится о единицах и округлениях. Он работает с Python 3.6 или новее.
hans 7 Дек 2019 в 22:05
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: 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))]
Peter Mortensen 27 Ноя 2019 в 18:07
Я посмотрел на модуль timeit, но кажется, что он только для небольших фрагментов кода. Я хочу, чтобы время всей программы.
$ python -mtimeit -n1 -r1 -t -s «from your_module import main» «main()»
Он запускает функцию your_module.main() один раз и печатает прошедшее время, используя функцию time.time() в качестве таймера.
Чтобы измерить время процессора (например, не включать время в течение time.sleep() ) для каждой функции, вы можете использовать модуль profile ( cProfile в Python 2):
$ python3 -mprofile your_module.py
Вы можете передать -p команде timeit выше, если хотите использовать тот же таймер, что и модуль profile .
jfs 28 Ноя 2019 в 08:47
В IPython «timeit» любой скрипт:
def foo(): %run bar.py timeit foo()
Peter Mortensen 27 Ноя 2019 в 17:54
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))
Peter Mortensen 27 Ноя 2019 в 17:45
Для пользователей данных, использующих Блокнот Jupyter
В ячейке вы можете использовать магическую команду 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.
Peter Mortensen 27 Ноя 2019 в 18: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)
The6thSense 6 Апр 2016 в 07:48
Следующий фрагмент распечатывает прошедшее время в удобном для человека формате .
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 20 Фев 2018 в 12:19
Устаревший с версии 3.3: поведение этой функции зависит на платформе: используйте взамен perf_counter () или process_time () , в зависимости от ваших требований иметь четко определенное поведение.
Вернуть значение (в долях секунды) счетчика производительности, то есть часы с максимально возможным разрешением для измерения короткого замыкания продолжительность . Он включает время, прошедшее во время сна, и общесистемный .
Вернуть значение (в долях секунды) суммы системы и пользовательское процессорное время текущего процесса. не включает прошедшее время во время сна
start = time.process_time() . do something elapsed = (time.process_time() — start)
Yas 18 Май 2016 в 03:49
Просто используйте модуль 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)
Peter rosevelt 14 Май 2020 в 19:15
Еще лучше для 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
vipulgupta2048 23 Дек 2019 в 19:16
Вы можете использовать профилировщик Python 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 :1() 1000 0.051 0.000 0.051 0.000 euler048.py:2() 1 0.005 0.005 0.061 0.061 euler048.py:2() 1 0.000 0.000 0.061 0.061 1 0.002 0.002 0.053 0.053 1 0.000 0.000 0.000 0.000 1 0.000 0.000 0.000 0.000 1 0.003 0.003 0.003 0.003
Peter Mortensen 27 Ноя 2019 в 17:38
Мне нравится вывод, который предоставляет модуль 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))
Peter Mortensen 27 Ноя 2019 в 17:39
Мне очень нравится ответ Пола Макгуайра, но я использую Python 3. Так что для тех, кто заинтересован: вот модификация его ответа это работает с 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»)
Если вы находите это полезным, вы все равно должны проголосовать за его ответ вместо этого, так как он сделал большую часть работы;).
Georgy 23 Сен 2019 в 08:59
import time start_time = time.clock() main() print time.clock() — start_time, «seconds»
time.clock() возвращает время процессора, что позволяет нам рассчитывать только время, используемое этим процессом (в любом случае в Unix). Документация гласит: «В любом случае, эту функцию нужно использовать для тестирования Python или алгоритмов синхронизации».
rayryeng 16 Мар 2015 в 17:16
В Linux или Unix:
$ time python yourprogram.py
Для более подробного вывода,
$ 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
vipulgupta2048 23 Дек 2019 в 17:57
Я поместил этот 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.)
Примечание. Версию вышеуказанного кода на Python 3 можно найти здесь или здесь.
Community 23 Май 2017 в 12:26
Это самый простой способ получить истекшее время для программы:
Напишите следующий код в конце вашей программы.
import time print(time.clock())
Источник: question-it.com
3 инструмента для отслеживания и визуализации выполнения вашего кода Python
Наверняка вам бы хотелось, чтобы вывод ошибки был более информативный, как на скриншоте ниже:
Так же возможно визуализировать, те строки кода,которые выполняются в реальном времени:
Итак, эта статья предоставит вам инструменты, чтобы сделать именно то, что описано выше. Вот эти 3 инструмента: Loguru — выводит исключения в коде snoop — напечатает строки кода, выполняемого в функции Heartrate — визуализирует выполнение программы Python в режиме реального времени И все, что нужно для использования этих инструментов, — в одну строчка кода!
Loguru — Print Better Exceptions
Loguru — это библиотека, цель которой — сделает вывод в Python приятным занятием. Loguru предоставляет множество интересных функций, но одна из функций, которые я считаю наиболее полезными, — это способность обнаруживать неожиданные ошибки и отображать их. Чтобы установить Loguru, введите команду pip install loguru
Чтобы понять, чем может быть полезен Loguru, представьте, что у вас есть 2 функции: div и div_numbers, и выполняется функция div_numbers.
from itertools import combinations def division(num1: int, num2: int): return num1/num2 def divide_numbers(num_list: list): «»»Division of 2 numbers in the number list «»» for comb in combinations(num_list, 2): num1, num2 = comb res = division(num1, num2) print(f» divided by is equal to .») if __name__ ==’__main__’: num_list = [2, 1, 0] divide_numbers(num_list)
Обратите внимание, что комбинации ([2,1,0], 2) возвращают [(2, 1), (2, 0), (1, 0)]. После выполнения приведенного выше кода мы получаем эту ошибку:
Обратите внимание, что комбинации ([2,1,0], 2) возвращают [(2, 1), (2, 0), (1, 0)]. После выполнения приведенного выше кода мы получаем эту ошибку:
Из выходных данных мы знаем, что ошибка возникает в строке, возвращающей num1 / num2, но мы не знаем, какие значения num1 и num2 вызывают ошибку. К счастью, это можно легко отследить, добавив декоратор Loguru logger.catch:
Добавление logger.catch упрощает понимание исключений! Оказывается, ошибка возникает при делении 2 на 0.
snoop — Print the Lines of Code being Executed in a Function
Что делать, если в коде нет ошибки, но мы хотим выяснить, как проходит выполнение код? Вот тут-то и пригодится snoop. snoop — это пакет Python, который печатает строки выполняемого кода вместе со значениями каждой переменной, добавляя только один декоратор. Чтобы установить snoop, введите:
pip install snoop
Представим, что у нас есть функция с именем factorial, которая находит факториал целого числа.
import snoop def factorial(x: int): if x == 1: return 1 else: return (x * factorial(x-1)) if __name__ == «__main__»: num = 5 print(f»The factorial of is «)
The factorial of 5 is 120
Чтобы понять, почему вывод factorial (5) равен 20, мы можем добавить декоратор snoop к функции factorial.
В выходных данных выше мы можем просмотреть значения переменных и то, какие строки кода выполняются. Теперь мы можем понять, как работает рекурсия!
Heartrate — Визуализация выполнения программы Python в режиме реального времени Если вы хотите визуализировать, какие строки выполняются и сколько раз они выполняются, попробуйте сердечный ритм.
Чтобы установить либу, введите:
pip install heartrate
Теперь давайте добавим heartrate.trace (browser = True) к нашему предыдущему коду. Это откроет окно браузера, отображающее визуализацию файла, в котором была вызвана функция trace ()
import heartrate heartrate.trace(browser=True) def factorial(x): if x == 1: return 1 else: return (x * factorial(x-1)) if __name__ == «__main__»: num = 5 print(f»The factorial of is «)
Новый браузер должен появиться, когда вы запустите приведенный выше код. Если нет, перейдите по адресу http: // localhost: 9999. Вы должны увидеть результат, как показано ниже:
Из вывода выше мы видим, что программа выполняется следующим образом: если x == 1 5 раз вернуть 1 раз return (x * factorial (x-1)) 4 раза Вывод имеет смысл, поскольку начальное значение x равно 5, и функция вызывается повторно, пока x не станет равным 1. Теперь давайте посмотрим — визуализации выполнение программы Python в реальном времени с использованием heartrate. Давайте добавим sleep (0,5), чтобы программа работала немного медленнее, и увеличим число до 20.
import heartrate from time import sleep heartrate.trace(browser=True) def factorial(x): if x == 1: return 1 else: sleep(0.5) return (x * factorial(x-1)) if __name__ == «__main__»: num = 20 print(f»The factorial of is «)
Мы можем видеть, какие строки кода выполняются и сколько раз выполнялась каждая из них в режиме реального времени.
Источник: uproger.com