Оптимизатор Производительности

⚡ Анализ Производительности Кода

📊 Результаты Профилирования

До оптимизации: 3.45 секунд

После оптимизации: 0.21 секунд

Улучшение: 94% быстрее ⚡

🐌 Найденные Проблемы

# ❌ Неэффективный код
def process_large_data(data):
    result = []
    for item in data:
        if item > 100:
            result.append(item * 2)
            result.append(item + 10)
            result.append(item - 5)
    return result

# ⚡ Оптимизированная версия
def process_large_data_optimized(data):
    # Использование list comprehension и extend
    result = []
    result.extend([
        value
        for item in data
        if item > 100
        for value in [item * 2, item + 10, item - 5]
    ])
    return result

# 🚀 Еще более быстрая версия с NumPy
import numpy as np

def process_large_data_numpy(data):
    arr = np.array(data)
    filtered = arr[arr > 100]
    
    # Векторизованные операции
    result = np.concatenate([
        filtered * 2,
        filtered + 10,
        filtered - 5
    ])
    
    return result.tolist()

# ❌ Повторные вычисления
def calculate_distances(points):
    distances = []
    for i, point1 in enumerate(points):
        for j, point2 in enumerate(points):
            if i != j:
                # Повторные вычисления sqrt каждый раз
                dist = ((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)**0.5
                distances.append(dist)
    return distances

# ⚡ С кешированием и оптимизацией
from functools import lru_cache
import math

@lru_cache(maxsize=1000)
def cached_distance(p1, p2):
    """Кешированное вычисление расстояния."""
    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

def calculate_distances_optimized(points):
    # Преобразуем в tuple для хеширования
    points_tuple = [tuple(p) for p in points]
    
    distances = []
    for i, point1 in enumerate(points_tuple):
        for j, point2 in enumerate(points_tuple[i+1:], i+1):
            # Используем кеш и вычисляем только уникальные пары
            dist = cached_distance(point1, point2)
            distances.extend([dist, dist])  # Добавляем для обеих пар
    
    return distances

# ❌ Медленное чтение файла
def process_large_file(filename):
    results = []
    with open(filename, "r") as f:
        for line in f:
            # Медленная обработка каждой строки
            processed = line.strip().upper().replace("old", "new")
            results.append(processed)
    return results

# ⚡ Батчевая обработка
def process_large_file_optimized(filename, batch_size=10000):
    results = []
    
    with open(filename, "r") as f:
        while True:
            # Читаем батчами
            lines = f.readlines(batch_size)
            if not lines:
                break
            
            # Векторизованная обработка батча
            batch_results = [
                line.strip().upper().replace("old", "new")
                for line in lines
            ]
            results.extend(batch_results)
    
    return results

# 🚀 Использование pandas для больших файлов
import pandas as pd

def process_large_file_pandas(filename):
    # Читаем весь файл сразу (эффективно для больших данных)
    df = pd.read_csv(filename, header=None, names=["text"])
    
    # Векторизованные операции pandas
    df["processed"] = (
        df["text"]
        .str.strip()
        .str.upper()
        .str.replace("old", "new", regex=False)
    )
    
    return df["processed"].tolist()

📈 Benchmarking код

import time
import cProfile
import pstats
from memory_profiler import profile

class PerformanceTester:
    """Класс для тестирования производительности."""
    
    @staticmethod
    def time_function(func, *args, **kwargs):
        """Замер времени выполнения функции."""
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        
        execution_time = end_time - start_time
        print(f"{{func.__name__}}: {{execution_time:.4f}} секунд")
        return result, execution_time
    
    @staticmethod
    def profile_function(func, *args, **kwargs):
        """Профилирование функции."""
        profiler = cProfile.Profile()
        profiler.enable()
        
        result = func(*args, **kwargs)
        
        profiler.disable()
        stats = pstats.Stats(profiler)
        stats.sort_stats("cumulative")
        stats.print_stats(10)  # Топ 10 самых медленных функций
        
        return result
    
    @profile  # Декоратор для анализа памяти
    def memory_test(self, func, *args, **kwargs):
        """Тест использования памяти."""
        return func(*args, **kwargs)

# Пример тестирования
if __name__ == "__main__":
    tester = PerformanceTester()
    
    # Тестовые данные
    large_data = list(range(100000))
    
    # Сравнение производительности
    print("=== Тестирование производительности ===")
    
    # Оригинальная версия
    _, time1 = tester.time_function(process_large_data, large_data)
    
    # Оптимизированная версия
    _, time2 = tester.time_function(process_large_data_optimized, large_data)
    
    # NumPy версия
    _, time3 = tester.time_function(process_large_data_numpy, large_data)
    
    # Результаты
    print(f"\nУлучшение оптимизированной версии: {{time1/time2:.1f}}x быстрее")
    print(f"Улучшение NumPy версии: {{time1/time3:.1f}}x быстрее")

🔧 Рекомендации по Оптимизации

• Векторизация: Используйте NumPy для численных операций
• Кеширование: lru_cache для повторяющихся вычислений
• Генераторы: Экономия памяти для больших данных
• Батчевая обработка: Группируйте операции ввода-вывода
• Профилирование: Регулярно измеряйте производительность