Профилирование и оптимизация

Правила оптимизации

«Преждевременная оптимизация — корень всех зол» — Дональд Кнут.

1. Сначала правильность, потом скорость.
2. Измеряйте, а не угадывайте. Узкое место почти всегда не там, где кажется.
3. Оптимизируйте горячие места: 90% времени тратится в 10% кода.
4. Алгоритм важнее микрооптимизаций: O(n²) → O(n) даёт больше, чем любые трюки.
5. После изменения — измерьте снова и убедитесь, что тесты зелёные.

Замеры

import timeit

setup = "data = list(range(1000))"
print("цикл:        ", timeit.timeit("r = []\nfor x in data: r.append(x * 2)", setup, number=2000))
print("включение:   ", timeit.timeit("[x * 2 for x in data]", setup, number=2000))
print("map + lambda:", timeit.timeit("list(map(lambda x: x * 2, data))", setup, number=2000))

print("sum генератор:", timeit.timeit("sum(x for x in data)", setup, number=2000))
print("sum встроенная:", timeit.timeit("sum(data)", setup, number=2000))

timeit повторяет фрагмент много раз и отключает сборщик мусора — для микрозамеров. В консоли: python -m timeit -s "data=list(range(1000))" "sum(data)". В IPython/Jupyter — %timeit.

Для участков программы — time.perf_counter():

import time
from contextlib import contextmanager

@contextmanager
def measure(label):
    start = time.perf_counter()
    yield
    print(f"{label}: {(time.perf_counter() - start) * 1000:.1f} мс")

with measure("сортировка 200 000 чисел"):
    sorted(range(200_000, 0, -1))

cProfile — где тратится время

import cProfile, pstats, io

def parse(line):
    return [int(x) for x in line.split(",")]

def validate(nums):
    return all(n >= 0 for n in nums)

def slow_lookup(nums, allowed):
    return [n for n in nums if n in allowed]            # allowed — список!

def process(lines):
    allowed = list(range(0, 1000, 3))
    total = 0
    for line in lines:
        nums = parse(line)
        if validate(nums):
            total += len(slow_lookup(nums, allowed))
    return total

lines = [",".join(str((i * j) % 1000) for j in range(20)) for i in range(800)]

profiler = cProfile.Profile()
profiler.enable()
process(lines)
profiler.disable()

out = io.StringIO()
pstats.Stats(profiler, stream=out).sort_stats("cumulative").print_stats(8)
print("\n".join(out.getvalue().splitlines()[:18]))

Колонки: ncalls — число вызовов, tottime — время в самой функции, cumtime — вместе с вызванными. Здесь видно, что время уходит в slow_lookup — поиск в списке. Замените allowed на множество и перезапустите пример.

Запуск для всей программы: python -m cProfile -s cumulative script.py или -o profile.out и просмотр в snakeviz.

Другие профилировщики

py-spy top --pid 12345                     # «top» для Python-процесса
py-spy record -o flame.svg --pid 12345     # flame graph

Приёмы ускорения

1. Алгоритм и структура данных

Самый большой выигрыш. set для поиска, dict для индекса, deque для очереди, heapq для top-k, сортировка + бинарный поиск, предвычисление.

2. Встроенные функции и включения

Встроенные (sum, min, max, sorted, any, str.join, collections.Counter) написаны на C. Включения быстрее ручного append в цикле.

import timeit
setup = "words = ['кот', 'пёс', 'кот', 'ёж'] * 2500"
manual = """
counts = {}
for w in words:
    if w in counts:
        counts[w] += 1
    else:
        counts[w] = 1
"""
print("вручную:", round(timeit.timeit(manual, setup, number=50), 3))
print("Counter:", round(timeit.timeit("Counter(words)", "from collections import Counter\n" + setup, number=50), 3))

3. Кеширование

functools.cache для чистых функций, кеш результатов запросов (Redis), cached_property.

4. Ленивость

Генераторы вместо списков для потоковой обработки — меньше памяти, быстрее старт.

5. Векторизация

import numpy as np

prices = np.random.rand(10_000_000)
total = (prices * 1.2).sum()         # одна операция на C над всем массивом — в 50–100 раз быстрее цикла

6. Ввод-вывод — главная причина медленных сервисов

• N+1 запросов: в цикле по 100 заказам делать запрос за клиентом → 101 запрос. Решение: JOIN, select_related/prefetch_related (Django), selectinload (SQLAlchemy).
• Батчи: executemany, bulk_create, пакетные API.
• Конкурентные сетевые запросы (asyncio, пул потоков).
• Индексы в базе данных, пагинация, кеширование.

7. Микрооптимизации (только в горячих циклах)

• локальная переменная вместо глобальной/атрибута (append = result.append);
• __slots__ для миллионов объектов;
• избегать лишних вызовов функций и исключений в горячем цикле.

Когда этого мало

Итог

• Сначала измерить: timeit, perf_counter, cProfile, py-spy.
• Алгоритм и структура данных дают больше всего; затем встроенные функции, кеш, ленивость, векторизация.
• В веб-сервисах время чаще всего уходит на ввод-вывод: N+1, индексы, батчи, конкурентность.
• Микрооптимизации — только в доказанно горячих местах; дальше — PyPy, Cython, Rust.