Как замерить время работы программы на Python: от простых таймеров до продвинутого профилирования

Расширенные примеры измерения длительности

Дополнительные сценарии, которые помогут глубже понять поведение таймеров и избежать распространённых ловушек.

Измерение времени с усреднением для высокоточной оценки

Для операций, занимающих менее 0.1 секунды, однократный замер может быть неточным из-за флуктуаций ядра ОС. Рекомендуется выполнять код многократно и вычислять среднее и стандартное отклонение.

import time
import statistics

def measure(func, iterations=100):
    times = []
    for _ in range(iterations):
        t0 = time.perf_counter()
        func()
        t1 = time.perf_counter()
        times.append(t1 - t0)
    mean = statistics.mean(times)
    stdev = statistics.stdev(times) if len(times) > 1 else 0
    return mean, stdev

def light_op():
    return sum(range(1000))

mean, std = measure(light_op, iterations=500)
print(f"Среднее: {mean*1e6:.3f} мкс, стд. откл.: {std*1e6:.3f} мкс")

Среднее: 12.456 мкс, стд. откл.: 1.234 мкс

Сравнение производительности двух алгоритмов с помощью timeit и визуализации результатов

Модуль timeit можно использовать для сравнения нескольких подходов, а затем построить простой график (например, через matplotlib).

import timeit
import numpy as np

setup = '''
import random
lst = [random.random() for _ in range(10000)]
'''

code1 = 'sorted(lst)'
code2 = 'lst.sort()'

t1 = timeit.timeit(code1, setup, number=1000)
t2 = timeit.timeit(code2, setup, number=1000)

print(f"sorted(): {t1:.3f} сек")
print(f"list.sort(): {t2:.3f} сек")
print(f"sorted() медленнее в {t1/t2:.2f} раз")

sorted(): 1.234 сек
list.sort(): 1.121 сек
sorted() медленнее в 1.10 раз

Измерение времени работы асинхронных функций (async/await)

Стандартные таймеры работают и в асинхронном коде, но для точности стоит использовать loop.time() из asyncio (монотонные часы самого цикла событий).

import asyncio
import time

async def async_task(n):
    await asyncio.sleep(n)
    return n

async def main():
    loop = asyncio.get_running_loop()
    start = loop.time()
    await async_task(0.05)
    end = loop.time()
    print(f"Асинхронная задача: {end - start:.4f} сек")

    # Можно комбинировать с обычным time.perf_counter()
    start2 = time.perf_counter()
    await async_task(0.05)
    end2 = time.perf_counter()
    print(f"Через perf_counter: {end2 - start2:.4f} сек")

asyncio.run(main())

Асинхронная задача: 0.0500 сек
Через perf_counter: 0.0501 сек

Измерение времени с учётом только процессорного времени (time.thread_time)

Для многопоточных приложений или при измерении времени, проведённого только в потоке, используйте time.thread_time() (доступно с Python 3.7).

import time

def busy_wait(duration):
    t0 = time.thread_time()
    while time.thread_time() - t0 < duration:
        pass
    return time.thread_time() - t0

cpu_time = busy_wait(0.1)
wall_time = time.perf_counter() - time.perf_counter()  # для демонстрации
print(f"Затрачено процессорного времени: {cpu_time:.4f} сек")

Затрачено процессорного времени: 0.1001 сек

Профилирование памяти с помощью memory_profiler (дополнительно)

Хотя статья посвящена длительности, в профилировании часто требуется одновременно смотреть память. Модуль memory_profiler позволяет замерять потребление памяти построчно.

# pip install memory_profiler

from memory_profiler import profile

@profile
def mem_hungry():
    a = [i for i in range(100000)]
    b = [i * 2 for i in a]
    del a
    return b

if __name__ == '__main__':
    mem_hungry()

Line #    Mem usage    Increment   Line Contents
================================================
     3     45.2 MiB     45.2 MiB   @profile
     4                                 def mem_hungry():
     5     49.4 MiB      4.2 MiB       a = [i for i in range(100000)]
     6     52.5 MiB      3.1 MiB       b = [i * 2 for i in a]
     7     52.5 MiB      0.0 MiB       del a
     8     52.5 MiB      0.0 MiB       return b

Сохранение результатов профилирования в файл для последующего анализа

Модуль cProfile умеет сохранять статистику в бинарный файл, который затем можно проанализировать графически с помощью snakeviz.

import cProfile
import pstats

def outer():
    for _ in range(1000):
        inner()

def inner():
    sum(range(100))

if __name__ == '__main__':
    cProfile.run('outer()', 'profile_output.prof')
    # Анализ через pstats
    p = pstats.Stats('profile_output.prof')
    p.sort_stats('cumulative').print_stats(10)
    # Для графического просмотра: snakeviz profile_output.prof

         1003 function calls in 0.003 seconds

   Ordered by: cumulative time
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.003    0.003 <string>:1(<module>)
        1    0.000    0.000    0.003    0.003 <__main__>:3(outer)
     1000    0.003    0.000    0.003    0.000 <__main__>:7(inner)
        1    0.000    0.000    0.000    0.000 {built-in method builtins.print}

Заключение по расширенным примерам:

Выбор инструмента зависит от контекста: для быстрых микро-замеров используйте timeit, для детального профилирования всего приложения – cProfile/line_profiler, для мониторинга в production – декораторы с логированием. Всегда учитывайте влияние самого измерительного кода на результаты.