Почему на чистом Python не пишут код для перемножения матриц?

Почему на чистом Python не пишут код для перемножения матриц?

Это отличный вопрос, который раскрывает фундаментальное ограничение Python. Ответ: производительность и архитектура языка.

Основные причины

1. Интерпретируемость и GIL

Python — интерпретируемый язык с Global Interpreter Lock (GIL):

• Каждая операция в цикле вызывает интерпретатор
• GIL блокирует многопоточность для CPU-bound задач
• Матричное умножение — это CPU-bound операция (мало I/O)

# Чистый Python: медленно
def matrix_multiply_pure(A, B):
    n, m, p = len(A), len(A[0]), len(B[0])
    result = [[0] * p for _ in range(n)]
    
    for i in range(n):
        for j in range(p):
            for k in range(m):
                result[i][j] += A[i][k] * B[k][j]  # 4 операции в цикле
    
    return result

# На матрице 1000x1000: 2-3 СЕКУНДЫ!

2. Динамическая типизация

Python проверяет типы в runtime:

• Каждое сложение A[i][k] * B[k][j] требует:
  • Проверки типа переменной
  • Поиска метода __mul__ и __add__
  • Создания промежуточного объекта в памяти

# Каждое умножение это примерно:
result = Python_Object.__mul__(A[i][k], B[k][j])
# Затем:
accum = Python_Object.__add__(result, accum)

Сравните с C:

// C: просто сложение два float
float temp = A[i][k] * B[k][j];
result[i][j] += temp;  // Одна CPU-инструкция

3. Дорогое управление памятью

• Python: каждое число int или float — это объект (~28 байт за число)
• NumPy: числа хранятся как примитивы (4-8 байт)

import sys

# Чистый Python
a = 5
print(sys.getsizeof(a))  # 28 байт!

# NumPy
import numpy as np
arr = np.array([5])
print(arr.itemsize)  # 8 байт

4. Отсутствие оптимизации циклов

• Python: интерпретирует каждую итерацию цикла
• NumPy: использует векторизацию (SIMD инструкции процессора)
• C/Fortran: компилятор может распараллелить цикл

# NumPy делает это эффективно
C = np.dot(A, B)  # Внутри — оптимизированные BLAS рутины

Benchmark реальных чисел

import time
import numpy as np

# Матрица 1000x1000
size = 1000
A = [[float(i+j) for j in range(size)] for i in range(size)]
B = [[float(i+j) for j in range(size)] for i in range(size)]

# Чистый Python: 6-10 СЕКУНД
start = time.time()
def matrix_mult(A, B):
    n, m, p = len(A), len(A[0]), len(B[0])
    C = [[sum(A[i][k] * B[k][j] for k in range(m)) for j in range(p)] for i in range(n)]
    return C
result = matrix_mult(A, B)
print(f"Pure Python: {time.time() - start:.2f}s")  # ~7 сек

# NumPy: 0.02 СЕКУНДЫ!
A_np = np.array(A)
B_np = np.array(B)
start = time.time()
C_np = np.dot(A_np, B_np)
print(f"NumPy: {time.time() - start:.4f}s")  # ~0.02 сек

# 350x БЫСТРЕЕ!

Правильный подход

NumPy для умножения матриц

import numpy as np

A = np.random.rand(1000, 1000)
B = np.random.rand(1000, 1000)

# Используй готовые функции
C = np.dot(A, B)  # или @
# C = A @ B  # Pythonic way в 3.5+

Почему работает быстро:

• NumPy использует BLAS (Basic Linear Algebra Subprograms)
• BLAS написана на Fortran 77 (оптимизирована за 40 лет)
• Использует SIMD инструкции (SSE, AVX)
• Параллелизирует на уровне процессора

CuPy для GPU

import cupy as cp

A_gpu = cp.asarray(A)
B_gpu = cp.asarray(B)
C_gpu = cp.dot(A_gpu, B_gpu)  # На GPU в 50-100x быстрее

Когда чистый Python ОК?

✅ Хорошо для:

• Маленькие матрицы (10x10)
• Для демонстрации алгоритма
• Для обучения (понимания матриц)

❌ Плохо для:

• ML/AI модели (миллионы операций)
• Научные вычисления
• Графика и обработка изображений

Вывод

Python — язык высокого уровня, не предназначен для численных вычислений. Для них используй:

• NumPy (CPU, общий случай)
• CuPy (GPU)
• TensorFlow/PyTorch (ML)
• Fortran/C++ (максимальная скорость)

Python отлично подходит для оркестрации вычислений, а не их выполнения.