Чем обусловлена медленность Python?

Причины медленности Python

Python часто критикуют за скорость исполнения, но это недоразумение основано на нескольких технических причинах, которые важно понимать.

1. Global Interpreter Lock (GIL)

В CPython (стандартная реализация) существует Global Interpreter Lock — мьютекс, который позволяет только одному потоку исполнять Python код одновременно:

import threading
import time

def cpu_bound_task():
    # Эта функция НЕ будет распараллелена на несколько ядер из-за GIL
    total = 0
    for i in range(100_000_000):
        total += i
    return total

# На многоядерной машине это НЕ ускорится
threads = [threading.Thread(target=cpu_bound_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

GIL был введен для упрощения управления памятью, но это полностью убирает параллелизм для CPU-bound задач. Python 3.13 экспериментирует с отключением GIL.

2. Интерпретируемый язык

Python — интерпретируемый язык, код компилируется в bytecode, который затем исполняется виртуальной машиной:

import dis

def add(a, b):
    return a + b

# Посмотреть bytecode
dis.dis(add)
# Каждая операция — это вызов функции интерпретатора

В то время как C компилируется непосредственно в машинный код:

int add(int a, int b) {
    return a + b;  // Прямая машинная инструкция
}

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

Python не знает тип переменной до runtime, что требует проверок:

def multiply(x, y):
    # Python должен проверить типы x и y и выполнить правильную операцию
    # Для int: быстрое умножение
    # Для str: повтор строки
    # Для list: повтор элементов
    return x * y

# С типизацией это предсказуемо
from typing import TypeVar
T = TypeVar(T, int, float, str)
def multiply_typed(x: T, y: T) -> T:
    return x * y

4. Управление памятью

Python использует подсчет ссылок для управления памятью, что добавляет overhead при каждой операции:

# За кулисами для каждого объекта
class PyObject:
    int ref_count  # Счетчик ссылок
    PyTypeObject *type  # Указатель на тип
    # ... другие поля

При присвоении, удалении, передаче параметра счетчик обновляется — это замедляет все.

5. Виртуальная машина

Bytecode исполняется медленнее машинного кода. Каждая операция — это поиск в таблице и вызов функции:

AST → Компиляция → Bytecode → Интерпретация → Машинный код

В отличие от скомпилированных языков:

AST → Компиляция → Машинный код

Как это решается на практике?

multiprocessing вместо threading для CPU-bound задач:

from multiprocessing import Pool

with Pool(processes=4) as pool:
    results = pool.map(cpu_bound_task, range(100))

Cython для критичных частей:

# fast.pyx
def fast_sum(int[:] arr):
    cdef long total = 0
    for i in range(arr.shape[0]):
        total += arr[i]
    return total

NumPy для численных вычислений (написан на C):

import numpy as np

arr = np.arange(1_000_000)
result = arr.sum()  # Исполняется на C, очень быстро

PyPy — JIT компилятор для Python:

# Код исполняется на 5-10x быстрее
pypy script.py

Вывод

Python медлен в основном из-за GIL, динамической типизации и того, что это интерпретируемый язык. Однако для большинства задач (веб-приложения, системы обработки данных) это не проблема, потому что:

1. IO-bound операции (сеть, база данных) доминируют
2. Критичные части можно оптимизировать
3. Экосистема предоставляет быстрые альтернативы (NumPy, Pandas, Polars)

Python — это язык для быстрой разработки, а не для скорости исполнения.