NumPy

Язык программирования Python изначально не предназначался для научных вычислений, однако с ранних этапов заинтересовал научное и инженерное сообщество. В 1995 году была учреждена специальная группа matrix-sig (SIG) с целью создания модульной поддержки массивов; в состав группы входил создатель Python Гвидо ван Россум, который расширил синтаксис Python (в частности, синтаксис индексации^[6]), чтобы облегчить программирование с использованием массивов^[7].

Реализация модуля для работы с матрицами была завершена Джимом Фултоном, а затем обобщена Джимом Хугунином и названа «Numeric»^[7] (также упоминалась как «Numerical Python extensions» или «NumPy»), с заимствованиями из языков APL, Basis, MATLAB, Фортран, S и S+, и других^[8][9]. Хугунин, работавший аспирантом в MIT^[9],^:10 перешёл в CNRI в 1997 году для работы над JPython^[7], после чего ведение проекта перешло к Полу Дюбуа из Ливерморской национальной лаборатории (LLNL)^[9].^:10 Среди ранних участников были также Дэвид Ашер, Конрад Хинсен и Трэвис Олифант^[9]:10

Для большей гибкости был разработан новый пакет под названием Numarray. Как и Numeric, он теперь считается устаревшим^[10].^[11]. Numarray обеспечивал более высокую производительность на больших массивах, но уступал Numeric на малых^[12], поэтому некоторое время оба пакета использовались параллельно. Последняя версия Numeric (v24.2) вышла 11 ноября 2005 года, а последняя версия Numarray (v1.5.2) — 24 августа 2006^[13].

Попытки включить Numeric в стандартную библиотеку Python не были реализованы из-за проблем с поддержкой исходного кода^[14].

В начале 2005 года разработчик NumPy Трэвис Олифант с целью объединения сообщества перенёс функционал Numarray в Numeric и выпустил итоговый пакет под названием NumPy 1.0 в 2006 году. Этот проект стал частью SciPy. Чтобы не требовать установки большого пакета SciPy только ради объекта массива, NumPy был выделен как отдельная библиотека. Поддержка Python 3 была добавлена с версией NumPy 1.5.0 в 2011 году^[15].

В последующие годы библиотека продолжила активно развиваться. В 2012 году вышел релиз 1.6.2, содержавший большое количество исправлений^[16]. Версия 1.8 (2013) перешла на единую кодовую базу для Python 2 и 3, отказавшись от утилиты 2to3^[17]. Важным шагом стал выпуск NumPy 1.17 в 2019 году, который полностью прекратил поддержку Python 2.7 и представил новый расширяемый генератор случайных чисел^[18]. В 2023 году, с выходом версии 1.26, проект перешёл на систему сборки Meson для поддержки Python 3.12^[19]. В июне 2024 года состоялся выпуск NumPy 2.0 — первого крупного релиза с 2006 года, который внёс значительные изменения в API и производительность. Проект продолжает активно развиваться^[20]: в июне 2025 года вышла версия 2.3.0^[20], а последней стабильной версией является 2.3.4 от 15 октября 2025 года^[20][21].

В 2011 году проект PyPy начал разработку собственной реализации NumPy API, известной как NumPyPy^[22]. Впоследствии этот проект был признан устаревшим^[23][24]. На 2025 год стандартный пакет NumPy полностью совместим с PyPy и устанавливается через pip^[23]. Совместимость обеспечивается через слой эмуляции CPython C API под названием cpyext, который, однако, может приводить к снижению производительности по сравнению с CPython из-за накладных расходов^[23][25]. Долгосрочным решением этой проблемы считается проект HPy — новый универсальный C API, который позволит C-расширениям, включая NumPy, работать на PyPy с сопоставимой с CPython скоростью^[23][26].

NumPy является проектом с открытым исходным кодом, который находится в стадии активной разработки. Проект поддерживается большим и разнообразным сообществом на платформе GitHub^[27]. О динамичном развитии свидетельствуют регулярные обновления, наличие публичной дорожной карты (roadmap)^[28] и крупные релизы, такие как NumPy 2.0 в 2024 году — первое значительное обновление API с 2006 года.

Процесс внесения существенных изменений в библиотеку формализован через систему предложений по улучшению NumPy (NumPy Enhancement Proposals, или NEP). Эта система была введена в конце 2017 года и служит основным механизмом для предложения новых крупных функций, сбора мнений сообщества и документирования проектных решений^[29].

Долгое время проект развивался исключительно на волонтёрских началах, однако в 2017 году он впервые получил значительное финансирование в размере 645 020 долларов от фонда Гордона и Бетти Мур^[30]. В последующие годы финансовую поддержку оказывала Chan Zuckerberg Initiative (CZI) в рамках программы поддержки критически важного открытого ПО для науки: гранты были выделены в 2019, 2020 и 2021 годах на улучшение структуры управления, документации, удобства использования и инициативы по повышению разнообразия и инклюзивности в сообществе^[31].

Для тестирования новейших функций и исправлений доступны предрелизные сборки. К ним относятся «ночные сборки» (nightly builds), которые автоматически создаются из основной ветки разработки и могут быть установлены из специального репозитория^[32][33]. Кроме того, любой желающий может скомпилировать библиотеку напрямую из исходного кода, чтобы получить доступ к самой актуальной версии проекта^[34]. Такие сборки активно используются как разработчиками NumPy, так и авторами других библиотек для заблаговременной адаптации своего кода к предстоящим изменениям^[35].

NumPy рассчитан на работу с CPython, референсной (интерпретируемой) реализацией Python. Написанные для неё математические алгоритмы часто работают медленнее компилируемых эквивалентов из-за отсутствия оптимизации компилятора. NumPy компенсирует эту особенность, предоставляя многомерные массивы и эффективные операции над ними, что требует частичного переписывания, главным образом «внутренних циклов», с использованием функций и операторов NumPy.

Взаимодействие с NumPy осуществляется не через графический интерфейс, а через программный интерфейс приложения (API)^[36]. Основным языком для работы с библиотекой является Python^[37], однако библиотека также предоставляет C API для интеграции с внешними библиотеками, написанными на C, и оптимизации производительности^[38]. Кроме того, существуют сторонние проекты, предоставляющие привязки (bindings) для использования NumPy в среде .NET на языках C# и F#^[39].

Библиотека поддерживает широкий спектр аппаратных платформ на уровне центральных процессоров (CPU), используя для ускорения вычислений специфичные для них наборы инструкций (SIMD)^[40]. К поддерживаемым архитектурам относятся x86-64, ARM (включая Apple silicon), IBM POWER и RISC-V^[40].

Использование NumPy приближает возможности Python к MATLAB, поскольку оба решения являются интерпретируемыми^[41] и позволяют быстро обрабатывать данные, если основная работа осуществляется над массивами/матрицами, а не скалярными значениями. При этом MATLAB обладает развитой экосистемой дополнительных модулей (напр., Simulink), в то время как NumPy глубоко интегрирован с Python. Доступны дополнительные библиотеки: SciPy предоставляет более широкий функционал для научных расчётов, а Matplotlib — инструменты для визуализации, аналогичные средствам MATLAB. Для работы с разрежёнными матрицами требуется использование модуля scipy.sparse. Внутри NumPy и MATLAB используют BLAS и LAPACK для операций линейной алгебры.

Связки Python с популярной библиотекой компьютерного зрения OpenCV используют массивы NumPy для хранения и обработки данных. Поскольку изображения с несколькими каналами могут быть представлены трёхмерными массивами, индексация, срезы и маскирование удобно реализуются через стандартные операции NumPy, что упрощает процесс программирования и отладки.

Многие операции NumPy освобождают глобальную блокировку интерпретатора, что позволяет использовать многопоточную обработку^[42].

Основным элементом NumPy является структура «ndarray» (n-мерный массив данных). В отличие от стандартных списков Python, массив NumPy содержит элементы одинакового (гомогенного) типа, что позволяет хранить их в виде непрерывного блока в памяти и обеспечивает высокую скорость вычислений^[43].

Объект ndarray представляет собой срез памяти и характеризуется несколькими ключевыми атрибутами^[43]:

• ndarray.data — буфер памяти, где физически хранятся элементы массива.
• ndarray.shape — кортеж, описывающий размер массива по каждой из его осей (измерений).
• ndarray.dtype — объект, описывающий тип данных элементов в массиве (например, int32, float64).
• ndarray.strides — кортеж, указывающий, сколько байт нужно «перешагнуть» в памяти, чтобы перейти к следующему элементу вдоль каждой оси. Эта система позволяет эффективно выполнять такие операции, как транспонирование или создание срезов, без копирования данных.

Массивы могут быть представлены как в собственных буферах памяти, так и интегрироваться с расширениями, написанными на C, C++, Python или Фортран, что обеспечивает совместимость с существующими вычислительными библиотеками. Эта функциональность активно используется в SciPy, который реализует обёртки для таких библиотек, как BLAS и LAPACK. В NumPy предусмотрена поддержка memory-mapped ndarrays.

Высокая производительность NumPy обеспечивается многоуровневой архитектурой, в которой высокоуровневый интерфейс на Python управляет быстрыми вычислениями, реализованными на компилируемых языках^[44]. Основная часть библиотеки написана на Python и C, также используются C++ и Fortran. Python используется для создания высокоуровневого API, а C, C++ и Fortran — для написания производительного ядра и интеграции с существующими вычислительными библиотеками, такими как BLAS и LAPACK^[44].

Ключевыми компонентами архитектуры являются:

• Низкоуровневое ядро. Большинство математических алгоритмов и операций над массивами реализованы на C и Fortran, что позволяет выполнять вычисления значительно быстрее, чем на интерпретируемом Python^[44].
• C-API. NumPy предоставляет C-API — интерфейс, который служит «мостом» между кодом на Python и низкоуровневым ядром^[45]. Он позволяет вызывать функции ядра из Python, манипулировать массивами `ndarray` напрямую из кода на C и расширять NumPy собственными модулями^[46].
• Универсальные функции (ufunc). Это функции, выполняющие быстрые поэлементные операции над массивами `ndarray` (например, `np.add`, `np.sin`). Они реализованы на C и используют векторизацию, при которой цикл операции выполняется на уровне скомпилированного кода, а не в Python, что многократно ускоряет вычисления^[47].
• Внутренние модули. Архитектура включает несколько ключевых модулей, организующих функциональность^[47]:
  • `Core`: определяет основные объекты, такие как `ndarray` и типы данных.
  • `Multiarray`: отвечает за работу с многомерными массивами, включая векторизацию и механизм «трансляции» (broadcasting).
  • `Umath` (Universal Math): содержит универсальные математические функции (ufunc).

Кроме того, NumPy включает подпакеты для конкретных задач, такие как `numpy.linalg` для линейной алгебры, `numpy.fft` для преобразования Фурье и `numpy.random` для генерации случайных чисел^[48].

Вставка или добавление элементов в массив NumPy не так тривиальна, как для списков Python. Например, функция np.pad(...) фактически создаёт новый массив требуемой формы, копирует туда данные и возвращает результат. Аналогично, np.concatenate([a1,a2]) создаёт новый массив, а не объединяет исходные без копирования. Изменение размерности с помощью np.reshape(...) возможно только при сохранении числа элементов. Это связано с тем, что массивы должны быть представлением непрерывного буфера памяти.

Алгоритмы, не реализуемые векторизацией, обычно выполняются медленнее (требуют pure Python), а сама векторизация может привести к увеличению требуемой памяти за счёт создания временных массивов. Для обхода этих ограничений были разработаны дополнительные средства компиляции численного кода, совместимые с NumPy: numexpr^[49] и Numba^[50] (JIT), а также статические компиляторы Cython и Pythran.

Многие современные задачи обработки больших данных ставят требования, которые выходят за рамки возможностей стандартных массивов NumPy. Например, массивы обычно должны помещаться в ОЗУ, что может быть недостаточно для анализа очень больших наборов данных, а операции NumPy по умолчанию выполняются на одном ЦП. В связи с этим был разработан ряд специализированных библиотек, которые расширяют возможности NumPy, сохраняя при этом совместимость с его API, особенно после выхода NumPy 2.0.

• Dask позволяет работать с распределёнными массивами, которые не помещаются в память, и выполняет вычисления параллельно. Проект активно поддерживает совместимость с последними версиями NumPy, что подтверждается выпуском Dask 2025.10.0 в октябре 2025 года, содержащим обновления для совместимости с NumPy 2.2^[51].
• JAX предназначен для высокопроизводительных вычислений на GPU и TPU. Несмотря на схожий API, JAX имеет фундаментальные отличия, такие как неизменяемость массивов. С сентября 2025 года JAX требует NumPy версии 2.0 или новее, а релиз JAX 0.8.0 (октябрь 2025) дополнительно улучшил совместимость с NumPy 2.2^[52].
• CuPy предоставляет NumPy-подобный интерфейс для вычислений на GPU с использованием CUDA от Nvidia. Библиотека стремится быть «заменой» NumPy с минимальными изменениями в коде. Версия v13.5.0 (август 2025) улучшила совместимость с NumPy 2.0 и добавила поддержку NumPy 2.3^[53].
• TensorFlow предоставляет модуль `tf.experimental.numpy`, который реализует подмножество API NumPy для выполнения кода в экосистеме TensorFlow. Это позволяет использовать привычный синтаксис NumPy для операций с тензорами^[54].
• MLX — фреймворк от Apple, представленный в 2025 году и разработанный для чипов Apple silicon. Он имеет API, намеренно схожий с NumPy, но отличается моделью унифицированной памяти (без копирования данных между CPU и GPU) и ленивыми вычислениями^[55][56].

NumPy предоставляет встроенные средства для сохранения массивов на диск и их последующей загрузки. Поддерживаются как простые текстовые форматы, так и собственные бинарные форматы, оптимизированные для скорости и эффективности.

Текстовые файлы (например, CSV) являются человекочитаемыми, что делает их удобными для обмена данными с другими программами. Для работы с ними предназначены следующие функции:

• Чтение. Для загрузки данных из текстовых файлов используются две основные функции:
  • numpy.loadtxt() — быстрая функция, предназначенная для загрузки однородных данных без пропусков^[57]. Позволяет указать разделитель, пропустить заголовки и выбрать определённые столбцы^[58].
  • numpy.genfromtxt() — более гибкая функция, способная обрабатывать файлы с пропущенными значениями, заменяя их на указанные (например, np.nan)^[59].
• Запись. Функция numpy.savetxt() сохраняет массив (обычно одномерный или двумерный) в текстовый файл, такой как .txt или .csv^[60]. Можно задать формат вывода чисел и разделитель столбцов^[61].

Для эффективного хранения данных NumPy предлагает собственные бинарные форматы, которые сохраняют полную информацию о массиве (форму, тип данных) и обеспечивают высокую скорость чтения и записи^[62].

• .npy — стандартный формат для сохранения одного массива NumPy. Для записи используется функция numpy.save(), а для чтения — numpy.load()^[59].
• .npz — это ZIP-архив, который может содержать несколько массивов, каждый в отдельном файле формата .npy^[63]. Это удобно для сохранения связанных наборов данных. Файлы создаются с помощью функций:
  • numpy.savez() — создаёт несжатый архив.
  • numpy.savez_compressed() — создаёт сжатый архив, что позволяет экономить дисковое пространство^[63].

Загрузка .npz-файлов также осуществляется функцией numpy.load(), которая возвращает объект, подобный словарю, где ключами служат имена массивов, а значениями — сами массивы^[63].

Помимо основных форматов, существуют функции для работы с «сырыми» бинарными данными. Метод ndarray.tofile() записывает содержимое массива в файл без метаданных, а функция numpy.fromfile() считывает данные из такого файла, требуя явного указания типа данных^[64].

Для работы с более сложными форматами файлов, такими как Excel (.xls, .xlsx) или научными форматами данных (например, HDF5), обычно используются специализированные библиотеки, которые тесно интегрируются с NumPy:

• Pandas — эффективно работает со сложными табличными данными (CSV, Excel) и позволяет легко преобразовывать их в массивы NumPy и обратно^[65].
• h5py, Zarr — библиотеки для работы с иерархическими форматами, предназначенными для хранения очень больших наборов данных, которые могут не помещаться в ОЗУ^[65].

NumPy обычно импортируется как np^[66].

import numpy as np
from numpy.typing import NDArray

a: NDArray[int] = np.array([[1, 2, 3, 4], [3, 4, 6, 7], [5, 9, 0, 5]])
a.transpose()

from numpy.typing import NDArray

a: NDArray[int] = np.array([1, 2, 3, 6])
b: NDArray[int] = np.linspace(0, 2, 4)
c: NDArray[int] = a - b
print(c)
# вывод: array([ 1.        ,  1.33333333,  1.66666667,  4.        ])
print(a ** 2)
# вывод: array([ 1,  4,  9, 36])

from numpy.typing import NDArray, float64

a: NDArray[float64] = np.linspace(-np.pi, np.pi, 100) 
b: float64 = np.sin(a)
c: float64 = np.cos(a)

print(np.sin(1))
# вывод: 0.8414709848078965
print(np.sin(np.array([1, 2, 3])))
# вывод: array([0.84147098, 0.90929743, 0.14112001])

import numpy as np
from numpy.linalg import solve, inv
from numpy.random import rand
from numpy.typing import NDArray, float32
a: NDArray[float32] = np.array([[1, 2, 3], [3, 4, 6.7], [5, 9.0, 5]])
print(a.transpose())
# вывод:
# array([[ 1. ,  3. ,  5. ],
#        [ 2. ,  4. ,  9. ],
#        [ 3. ,  6.7,  5. ]])
print(inv(a))
# вывод:
# array([[-2.27683616,  0.96045198,  0.07909605],
#        [ 1.04519774, -0.56497175,  0.1299435 ],
#        [ 0.39548023,  0.05649718, -0.11299435]])
b: NDArray[int] =  np.array([3, 2, 1])
print(solve(a, b))
# вывод: array([-4.83050847,  2.13559322,  1.18644068])
c: NDArray[float32] = rand(3, 3) * 20
print(c)
# вывод:
# array([[  3.98732789,   2.47702609,   4.71167924],
#        [  9.24410671,   5.5240412 ,  10.6468792 ],
#        [ 10.38136661,   8.44968437,  15.17639591]])
print(np.dot(a, c))
# вывод:
# array([[  53.61964114,   38.8741616 ,   71.53462537],
#        [ 118.4935668 ,   86.14012835,  158.40440712],
#        [ 155.04043289,  104.3499231 ,  195.26228855]])
print(a @ c)
# вывод:
# array([[  53.61964114,   38.8741616 ,   71.53462537],
#        [ 118.4935668 ,   86.14012835,  158.40440712],
#        [ 155.04043289,  104.3499231 ,  195.26228855]])

import numpy as np
from numpy.typing import NDArray, float64

M: NDArray[float64] = np.zeros(shape=(2, 3, 5, 7, 11))
T: NDArray[float64] = np.transpose(M, (4, 2, 1, 3, 0))
print(T.shape)
# вывод: (11, 5, 3, 7, 2)

import cv2
import numpy as np
from numpy.typing import NDArray, float32

r: NDArray[float32] = np.reshape(np.arange(256*256)%256,(256,256))
g: NDArray[float32] = np.zeros_like(r)
b: NDArray[float32] = r.T
print(cv2.imwrite("gradients.png", np.dstack([b,g,r])))
# вывод: True

Функциональный вариант Python и векторизованный вариант NumPy.

### Пример на функциональном Python ###
from typing import Callable, List

points: List[List[int]] = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]
qPoint: List[int] = [4,5,3]
edistance: Callable[[List[float], List[float]], float] = lambda a, b: sum((a1 - b1) ** 2 for a1, b1 in zip(a, b)) ** 0.5 
nearest: List[int] = min((edistance(i, qPoint), i) for i in points)[1] 
print(f"Nearest point to q: {nearest}")
# вывод: Nearest point to q: [3, 4, 4]

### Аналог на NumPy ###
import numpy as np
from numpy.typing import NDArray

points: NDArray[int] = np.array([[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]])
qPoint: NDArray[int] = np.array([4,5,3])
minIdx: int = np.argmin(np.linalg.norm(points-qPoint, axis=1))
print(f"Nearest point to q: {points[minIdx]}")
# вывод: Nearest point to q: [3 4 4]

Быстрое подключение кода на Fortran к Python-скриптам^[67][68].^[69]

В последних версиях библиотеки продолжилось развитие инструмента. Важным изменением стал продолжающийся переход от `distutils` к Meson в качестве системы сборки, что стало поведением по умолчанию для F2PY начиная с NumPy 1.26.x при использовании Python 3.12 и новее^[70]. При этом Meson не устанавливается как прямая зависимость, и пользователь должен самостоятельно настроить сборочное окружение^[71]. Релиз NumPy 2.2.0 (декабрь 2024 года) исправил регрессию, из-за которой F2PY некорректно обрабатывал модули, содержащие только присваивания переменных, а также устранил проблемы при работе с несколькими модулями в одном файле^[72].

! Пример вызова нативного кода Fortran из Python через f2py
subroutine ftest(a, b, n, c, d)
  implicit none
  integer, intent(in)  :: a, b, n
  integer, intent(out) :: c, d
  integer :: i
  c = 0
  do i = 1, n
    c = a + b + c
  end do
  d = (c * n) * (-1)
end subroutine ftest

from typing import Tuple
import foo
import numpy as np

a: Tuple[int, int] = foo.ftest(1, 2, 3)
print(a)
# вывод: (9,-27)
help("foo.ftest")
# описание: foo.ftest.__doc__