Как профилировать производительность Python-кода и какие инструменты для этого существуют?

А, профилирование, говоришь? Ну это ж святое дело, когда код начинает тормозить как пьяный мужик на льду, а ты сидишь и гадаешь, в каком именно месте он, сука, споткнулся. Сейчас разжуём, как эти штуки работают, чтобы не гадать на кофейной гуще.

Профилирование в Python — это, по сути, когда ты берёшь свой код и начинаешь его препарировать, как лягушку на биологии, чтобы найти, какая именно функция или строчка жрёт твоё процессорное время или память, как не в себя. Эти места и есть «узкие места», или, как их ещё называют, bottlenecks. Нашли — можно начинать оптимизировать, а не тыкать пальцем в небо.

Вот какие инструменты у нас есть для этого благородного дела:

1. cProfile (и его менее удачливый брат profile)

cProfile — это наш родной, встроенный в Питон, профилировщик, который написан на C, поэтому он сам по себе не тормозит как черепаха. Он собирает кучу статистики: кто кого вызывал, сколько раз и, главное, сколько времени на это ушло. profile — это такая же штука, но на чистом Питоне, поэтому он сам может стать тем самым узким местом, которое ты ищешь. Его лучше не трогать, честно.

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

Вот как это выглядит в деле:

import cProfile
import pstats # Эта штука поможет красиво вывести результаты, а не свалку цифр

def calculate_sum(n):
    """Ну типа функция, которая что-то считает."""
    total = 0
    for i in range(n):
        total += i
    return total

def main_task():
    """А это наша основная работёнка, которую мы будем разбирать по косточкам."""
    calculate_sum(1_000_000)
    calculate_sum(500_000)

# Запускаем наш детектив
profiler = cProfile.Profile()
profiler.enable() # Включаем прослушку

main_task() # Выполняем подозрительный код

profiler.disable() # Выключаем, всё записали

# А теперь смотрим, что наговорили
stats = pstats.Stats(profiler)
# Сортируем по общему времени, проведённому в функции (включая вызовы внутри неё), и показываем топ-10
stats.sort_stats('cumulative').print_stats(10)
# Если хочешь сохранить отчёт в файл и потом поковыряться, раскомментируй строку ниже
# stats.dump_stats('profile_results.prof')

Выполнишь это — и получишь табличку, где сразу видно, какая функция была самой прожорливой. Иногда результаты просто пиздец как удивляют.

2. line_profiler (в паре с kernprof)

А вот это уже более хирургический инструмент. line_profiler — это не встроенная штука, её надо ставить отдельно (pip install line_profiler). Его фишка в том, что он показывает время выполнения каждой отдельной строчки внутри функции. Представь, что cProfile сказал тебе: «Вон та комната — самая шумная». А line_profiler заходит в комнату и тычет пальцем: «Вот этот конкретный чувак у рояля орет громче всех!».

Когда юзать: Когда ты уже знаешь, какая функция тормозит, но нихрена не понимаешь, какая именно строчка в ней — главный тормоз.

Как с ним работать:

1. Ставим: pip install line_profiler

2. Размечаем код: Над функциями, которые хочешь исследовать до каждой запятой, вешаешь волшебный декоратор @profile.

   # my_script.py
   @profile
   def calculate_sum_detailed(n):
       total = 0
       for i in range(n):
           total += i # Вот тут-то он и покажет, сколько времени уходит на каждое сложение
       return total
   
   @profile
   def another_slow_part():
       _ = [x * x for x in range(100_000)] # А тут посмотрим на генератор списка
   
   def main_task_with_line_profiler():
       calculate_sum_detailed(1_000_000)
       another_slow_part()
   
   if __name__ == '__main__':
       main_task_with_line_profiler()

3. Запускаем магию: Не через обычный python, а через специальную команду kernprof.

   kernprof -l -v my_script.py

   И вуаля — в консоль польётся подробнейший отчёт по каждой строчке. Иногда смотришь и думаешь: «Ни хуя себе, эта, вроде бы невинная, строка жрёт 80% всего времени!».

3. memory_profiler

А это, блядь, уже совсем другая опера. Если предыдущие ребята следили за временем, то memory_profiler следит за памятью. Тоже ставится отдельно (pip install memory_profiler). Он показывает, сколько оперативки сжирает каждая строчка твоего кода. Незаменим, когда твоя программа начинает жрать память, как голодный студент в столовой, и ты не можешь понять, кто виноват.

Когда юзать: Когда у тебя подозрение на утечку памяти, или просто программа занимает овердохуища оперативки, и непонятно почему.

Как его приручить:

1. Ставим: pip install memory_profiler

2. Размечаем код: Тут тоже нужен декоратор @profile, но импортировать его надо из memory_profiler, чтобы не было путаницы с line_profiler.

   # my_memory_script.py
   from memory_profiler import profile # Важно! Импорт именно отсюда
   
   @profile
   def create_large_list():
       a = [i for i in range(10**6)] # Создаём один здоровенный список
       b = [i for i in range(2 * 10**6)] # И второй, ещё больше
       del a # А вот тут мы один удаляем, освобождая память
       return b
   
   if __name__ == '__main__':
       _ = create_large_list()

3. Запускаем: Опять же, особым способом.

   python -m memory_profiler my_memory_script.py

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

Вот так вот, комбинируя эти инструменты, можно не гадать, а точно знать, где в коде сидит собака, сука, которая всё тормозит или всю память сжирает. Главное — не бояться их использовать, а то некоторые пишут код, как Лев Толстой романы, и боятся заглянуть внутрь, а там, блядь, один сплошной Герасим с мешком.