Оптимизация производительности Python-приложений: профайлеры и техники

class DataProcessor:
    def __init__(self):
        self._cache = {}
        self._hits = 0
        self._misses = 0
    
    def process(self, data_id, expensive_computation):
        """Кеширует результат дорогой операции."""
        if data_id in self._cache:
            self._hits += 1
            return self._cache[data_id]
        
        self._misses += 1
        result = expensive_computation(data_id)
        self._cache[data_id] = result
        return result
    
    def cache_stats(self):
        return {"hits": self._hits, "misses": self._misses, 
                "hit_rate": self._hits/(self._hits+self._misses) if (self._hits+self._misses) > 0 else 0}

2.5. Оптимизация ввода-вывода

Буферизация операций с файлами:

# Медленно: много маленьких операций
def write_slow(filename, lines):
    with open(filename, 'w') as f:
        for line in lines:
            f.write(line + '\n')  # Каждая запись = системный вызов

# Быстро: буферизация
def write_fast(filename, lines):
    with open(filename, 'w', buffering=8192) as f:  # 8KB буфер
        # Или собираем все в одну строку
        content = '\n'.join(lines)
        f.write(content)

# Еще лучше для больших файлов: chunking
def write_large_file(filename, data_generator, chunk_size=10000):
    with open(filename, 'w', buffering=8192) as f:
        chunk = []
        for item in data_generator:
            chunk.append(str(item))
            if len(chunk) >= chunk_size:
                f.write('\n'.join(chunk) + '\n')
                chunk = []
        if chunk:
            f.write('\n'.join(chunk))

Асинхронный I/O с asyncio:

import asyncio
import aiohttp
import time

# Синхронные запросы (медленно)
def sync_fetch(urls):
    import requests
    results = []
    for url in urls:
        results.append(requests.get(url).text[:100])
    return results

# Асинхронные запросы (быстро)
async def async_fetch(session, url):
    async with session.get(url) as response:
        return (await response.text())[:100]

async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [async_fetch(session, url) for url in urls]
        return await asyncio.gather(*tasks)

# Сравнение
urls = ['https://httpbin.org/delay/1'] * 10  # 10 запросов по 1 секунде

# Синхронно: ~10 секунд
# Асинхронно: ~1 секунда

2.6. Оптимизация баз данных

Пакетные операции в Django ORM:

# Медленно: N+1 запрос
def create_users_slow(usernames):
    for username in usernames:
        User.objects.create(username=username)  # Каждый create = отдельный INSERT

# Быстро: bulk_create
from django.db import transaction

def create_users_fast(usernames):
    users = [User(username=username) for username in usernames]
    User.objects.bulk_create(users)  # Один запрос с множеством VALUES
    
# select_related и prefetch_related для оптимизации связанных объектов
def get_articles_with_authors():
    # Плохо: N+1 запрос для авторов
    articles = Article.objects.all()
    for article in articles:
        print(article.author.name)  # Отдельный запрос для каждого автора
    
    # Хорошо: один JOIN
    articles = Article.objects.select_related('author').all()
    for article in articles:
        print(article.author.name)  # Автор уже загружен

# Оптимизация сложных запросов через values() и only()
def get_article_stats():
    # Загружаем только нужные поля
    return (Article.objects
            .filter(published=True)
            .values('category', 'author_id')
            .annotate(count=Count('id'))
            .order_by('-count'))

Оптимизация для веб-приложений

3.1. Кеширование в Django