Работа с векторами в Python

В Python нет встроенного типа «вектор». Вектор — это одномерный массив NumPy: ставим библиотеку командой pip install numpy, затем пишем np.array([1, 2, 3]). Сложение и умножение на скаляр выполняются поэлементно, скалярное произведение даёт np.dot() или оператор @, длину — np.linalg.norm(). Остальное надстраивается над этими четырьмя операциями.

Что стоит забрать из статьи сразу:

• список Python и вектор — не одно и то же: на миллионе чисел массив NumPy занял у нас 7,6 МБ против 30,5 МБ у списка;
• скалярное произведение считается тремя способами — np.dot(), np.vecdot() и оператор @;
• векторное произведение np.cross() с 2-мерными векторами объявлено устаревшим в NumPy 2.0 — рабочий вариант только трёхмерный;
• угол между векторами и косинусная близость собираются из двух функций: np.dot() и np.linalg.norm();
• векторизация вместо цикла дала на нашем замере ускорение в 350–450 раз на скалярном произведении.

Дальше — по шагам: установка, создание, весь набор операций, замер скорости, визуализация и разбор ошибок, на которых спотыкаются чаще всего.

Что такое вектор в Python и почему обычный список не подходит

Вектор — математический объект, у которого есть величина и направление. В коде он выглядит как упорядоченный набор чисел: [1, 2, 3] — это вектор в трёхмерном пространстве. На векторах держатся анализ данных, машинное обучение, компьютерная графика, физика и робототехника: координаты, признаки объекта, эмбеддинги текста — всё это векторы.

Формально сложить два списка Python можно, но результат будет не тем, что нужно: [1, 2, 3] + [4, 5, 6] вернёт [1, 2, 3, 4, 5, 6] — конкатенацию, а не поэлементную сумму. Умножение списка на число тоже даёт не масштабирование, а повторение. Поэтому в Python вектор представляют массивом NumPy, где арифметические операторы переопределены под математику, а не под работу с последовательностями.

Второй аргумент — память. Список из миллиона чисел float в нашем замере занял 30,5 МБ, потому что хранит указатели на отдельные объекты-числа по 24 байта каждый. Массив NumPy того же размера — 7,6 МБ: это непрерывный блок чисел float64 без обёрток. Разница вчетверо, и она растёт вместе с объёмом данных.

Свой класс вектора со сложением через оператор + написать можно — механика описана в разборе методов __add__() и __radd__(). Для учебной задачи это полезно, для расчётов — нет: цикл на чистом Python проигрывает NumPy на порядки, и ниже мы это измерили.

Установка NumPy — библиотеки для векторов в Python

NumPy — основной пакет для научных вычислений в Python. Он даёт массивы, матрицы и большой набор математических функций для работы с ними. Ставится через pip, штатный установщик пакетов:

pip install numpy

Если проект уже собран под виртуальное окружение, команду выполняют внутри него. Проверить, что установка прошла и какая версия подтянулась:

import numpy as np

print(np.__version__)

Версия важна: в ветке 2.x поменялись некоторые правила линейной алгебры, и часть примеров из старых руководств выдаёт предупреждения. Все примеры ниже проверены на Python 3.14.3 и NumPy 2.4.4.

Сокращение np — не требование, а общепринятое соглашение сообщества: под этим псевдонимом библиотека фигурирует в документации и в чужом коде, поэтому переименовывать её не стоит.

Чем NumPy выигрывает у голых списков:

• Скорость: операции над массивом выполняются в скомпилированном коде, без интерпретируемого цикла.
• Функциональность: линейная алгебра, статистика, преобразования формы, генерация случайных чисел — в одной библиотеке.
• Компактность записи: сумма двух векторов — это a + b, а не цикл на четыре строки.
• Память: однородный массив без объектов-обёрток над каждым числом.

Как создать вектор в Python: пять рабочих способов

Базовый способ — передать список в np.array():

import numpy as np

vector = np.array([1, 2, 3])

print(vector)        # [1 2 3]
print(vector[0])     # 1 — доступ к первому элементу
print(vector.shape)  # (3,) — одномерный массив из трёх элементов
print(vector.dtype)  # int64

Атрибут shape здесь — главный диагностический инструмент: запись (3,) означает именно вектор, а (3, 1) — уже матрицу-столбец, и операции над ними ведут себя по-разному.

Остальные способы пригодятся, когда вектор нужно не набрать руками, а сгенерировать:

np.arange(0, 10, 2)      # [0 2 4 6 8] — с шагом
np.linspace(0, 1, 5)     # [0.   0.25 0.5  0.75 1.  ] — N точек на отрезке
np.zeros(4)              # [0. 0. 0. 0.] — заготовка под накопление
np.ones(3)               # [1. 1. 1.]
np.random.default_rng(42).random(3)   # три случайных числа с фиксированным зерном

np.arange() задаёт шаг, np.linspace() — количество точек: первое удобно для индексов, второе — для сеток под графики. Фиксированное зерно в генераторе случайных чисел делает пример воспроизводимым, что важно для расчётов, которые кто-то будет перепроверять.

Базовые операции с векторами в Python

Массивы одинаковой длины складываются и вычитаются поэлементно — так же, как в учебнике по линейной алгебре:

vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

sum_vector = vector1 + vector2    # [5 7 9]
diff_vector = vector1 - vector2   # [-3 -3 -3]

Умножение и деление на скаляр действуют на каждый элемент:

scaled_vector = vector1 * 2   # [2 4 6]
divided_vector = vector1 / 2  # [0.5 1.  1.5]

Обратите внимание на тип результата: деление всегда возвращает float64, даже если на входе были целые числа. Если дальше по коду ожидается целочисленный массив, тип задают явно через astype().

Отдельный подводный камень — звёздочка между двумя векторами. vector1 * vector2 даёт не скалярное произведение, а поэлементное [4 10 18]. Это частая ошибка при переносе формул из математической записи в код.

Скалярное произведение: три способа записи

Скалярное произведение перемножает соответствующие элементы и складывает результаты. Это операция, на которой держатся косинусная близость, проекции и почти все алгоритмы машинного обучения:

dot_product = np.dot(vector1, vector2)        # 32
same_result = vector1 @ vector2               # 32
also_same = np.vecdot(vector1, vector2)       # 32

Все три строки дают 32 — это 1·4 + 2·5 + 3·6. Разница в назначении:

• np.dot() — исторический универсал: для одномерных массивов считает скалярное произведение, для двумерных — матричное умножение.
• Оператор @ — сокращение для np.matmul. В документации NumPy сказано прямо: «The @ operator can be used as a shorthand for np.matmul on ndarrays». От dot он отличается тем, что умножение на скаляр запрещено — для этого есть *.
• np.vecdot() и его псевдоним np.linalg.vecdot() появились в NumPy 2.0 в наборе функций, приведённых к стандарту Array API. Это самый явный способ сказать в коде «здесь именно векторное скалярное произведение».

Практический вывод: для новых расчётов на векторах берите @ или np.vecdot() — они не меняют смысл при переходе к двумерным данным, тогда как np.dot() в этом случае молча переключается на матричное умножение.

Векторное произведение векторов в Python: только три измерения

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

a = np.array([1, 0, 0])
b = np.array([0, 1, 0])

print(np.cross(a, b))   # [0 0 1]

Здесь спрятано изменение, которое ломает старые руководства. В NumPy 2.0 двумерный вариант объявлен устаревшим — в примечаниях к релизу это записано так: «Arrays of 2-dimensional vectors for np.cross have been deprecated. Use arrays of 3-dimensional vectors instead». При запуске np.cross(np.array([1, 2]), np.array([3, 4])) на NumPy 2.4.4 мы получили результат -2 вместе с предупреждением DeprecationWarning: Arrays of 2-dimensional vectors are deprecated. Use arrays of 3-dimensional vectors instead. (deprecated in NumPy 2.0). Код пока работает, но полагаться на него не стоит: плоскую задачу дополняют нулевой третьей координатой.

Тем же релизом добавлена функция numpy.linalg.cross() — по описанию из примечаний, «It differs from numpy.cross by accepting three-dimensional vectors only». Если нужен строгий контроль размерности, берите её.

Длина, нормализация и угол между векторами

Длину (норму) вектора считает np.linalg.norm(). По умолчанию это евклидова норма — корень из суммы квадратов:

v = np.array([3.0, 4.0])

print(np.linalg.norm(v))          # 5.0
print(np.linalg.vector_norm(v))   # 5.0 — вариант из NumPy 2.0

Нормализация — масштабирование вектора до длины 1 с сохранением направления. Нужна почти везде, где сравнивают объекты по признакам:

normalized_vector = v / np.linalg.norm(v)   # [0.6 0.8]

Угол между векторами собирается из скалярного произведения и двух норм. На векторах [1, 2, 3] и [4, 5, 6] наш расчёт дал косинус 0,9746 и угол 12,93 градуса:

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

print(round(float(cos_sim), 4))                  # 0.9746
print(round(float(np.degrees(np.arccos(cos_sim))), 2))   # 12.93

Это и есть косинусная близость — метрика, по которой поисковые и рекомендательные системы решают, насколько два объекта похожи. На ней же работают алгоритмы рекомендаций, сравнивающие профиль пользователя с профилем контента.

Для двух и трёх координат без NumPy можно обойтись стандартной библиотекой: по документации модуля math, math.dist(p, q) возвращает «the Euclidean distance between two points p and q» и добавлен в версии 3.8, а math.hypot() с той же версии принимает произвольное число координат.

Операции с векторами в Python: сводная таблица

Насколько NumPy быстрее цикла: наш замер

Аргумент «NumPy быстрее» обычно подают без чисел, поэтому мы измерили разницу сами. Условия: Python 3.14.3, NumPy 2.4.4, процессор AMD64, два вектора по 1 000 000 случайных чисел float64, замер через timeit, пять повторов, берём лучший результат; скрипт прогонялся трижды, в таблице — диапазон по трём прогонам.

Разрыв между строками объясним: скалярное произведение сворачивается в одно число, и NumPy отдаёт его в оптимизированную реализацию линейной алгебры целиком. Сложение обязано выделить новый массив на миллион элементов, и часть выигрыша съедает работа с памятью — отсюда ≈50× вместо 350–450×.

Мини-вывод: цифры зависят от железа и версий, но порядок устойчив. Как только в задаче появляются десятки тысяч элементов, цикл на списках перестаёт быть вариантом — и именно это, а не удобство синтаксиса, делает NumPy стандартом для расчётов.

Визуализация векторов с помощью Matplotlib

Показать вектор стрелкой на плоскости умеет функция quiver() из Matplotlib. Это помогает на этапе разбора линейной алгебры и при проверке расчётов — ошибку в знаке видно глазом быстрее, чем в распечатке чисел:

import numpy as np
import matplotlib.pyplot as plt

vector1 = np.array([2, 3])
origin = np.array([0, 0])   # начало координат

plt.quiver(*origin, *vector1, angles='xy', scale_units='xy', scale=1)
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.grid(True)
plt.gca().set_aspect('equal')
plt.show()

Ключевая деталь — тройка аргументов angles='xy', scale_units='xy', scale=1. Без неё Matplotlib масштабирует стрелку по своим внутренним правилам, и длина на картинке перестаёт соответствовать длине вектора. Строка set_aspect('equal') выравнивает масштаб осей, иначе прямой угол между перпендикулярными векторами выглядит косым.

Пять ошибок, на которых спотыкаются чаще всего

• Путают * и скалярное произведение. Звёздочка между массивами перемножает элементы попарно. Скалярное произведение — @, np.vecdot() или np.dot().
• Складывают векторы разной длины. NumPy не дополняет короткий вектор нулями, а выбрасывает ошибку формы. Перед операцией сверяйте a.shape и b.shape.
• Считают np.cross() на плоскости. После NumPy 2.0 это устаревший путь, выдающий предупреждение. Дополняйте плоский вектор третьей нулевой координатой.
• Нормализуют нулевой вектор. Деление на нулевую норму даёт nan и тихо портит дальнейшие расчёты. Норму проверяют до деления.
• Теряют точность на целых числах. Массив с dtype=int64 при делении переходит в float64, а при операциях «на месте» через /= вызовет ошибку приведения типа. Тип задают сразу: np.array([1, 2, 3], dtype=float).

Мини-вывод: четыре ошибки из пяти ловятся одной привычкой — печатать shape и dtype массива перед тем, как с ним что-то делать.

Где векторы работают на практике

В машинном обучении вектор — это представление объекта: строка таблицы с признаками, эмбеддинг текста или картинки. Сравнение таких представлений через косинусную близость лежит в основе поиска похожего контента и рекомендаций. Языковые модели работают с векторами того же типа — их размерность и способ обучения различают разные семейства моделей.

В аналитике вектор — это столбец датасета, и векторизованные операции заменяют циклы при пересчёте метрик. В графике и робототехнике векторами задают положение, скорость и направление; нормаль к поверхности там считают через np.cross(). В физических расчётах на векторах строят силы и моменты.

Частые вопросы про векторы в Python

Есть ли в Python встроенный тип для векторов?

Нет. В Python нет встроенного типа данных для векторов: список складывается конкатенацией, а не поэлементно. Вектор представляют одномерным массивом NumPy — np.array([1, 2, 3]), где арифметические операторы работают по правилам линейной алгебры.

Чем np.dot отличается от оператора @?

На одномерных векторах обе записи дают одинаковый результат. Оператор @ — сокращение для np.matmul, он запрещает умножение на скаляр. А np.dot на двумерных данных переключается на матричное умножение, поэтому в коде, который может получить матрицу вместо вектора, надёжнее @ или np.vecdot.

Как посчитать угол между двумя векторами в Python?

Через косинус: разделить скалярное произведение на произведение норм, затем взять арккосинус. Код — np.arccos(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))), результат переводится в градусы через np.degrees(). Для векторов [1, 2, 3] и [4, 5, 6] получается 12,93 градуса.

Почему np.cross выдаёт предупреждение?

Потому что вы передали двумерные векторы. В NumPy 2.0 такие массивы для np.cross объявлены устаревшими, рекомендуется использовать трёхмерные. Плоскую задачу решают дополнением третьей нулевой координаты.

Насколько NumPy быстрее обычного цикла?

На нашем замере (Python 3.14.3, NumPy 2.4.4, векторы по 1 000 000 чисел) скалярное произведение через np.dot — ускорение в 350–450 раз по трём прогонам. Поэлементное сложение ускорилось примерно в 50 раз.

Как найти длину вектора без NumPy?

Стандартной библиотекой: math.hypot(*coords) возвращает евклидову норму и с версии Python 3.8 принимает любое число координат. Для расстояния между двумя точками есть math.dist(p, q) из той же версии.

Что запомнить о работе с векторами в Python

Вектор в Python — это одномерный массив NumPy. Четыре операции покрывают почти все задачи: поэлементная арифметика, скалярное произведение через @, норма через np.linalg.norm() и нормализация делением на неё. Векторное произведение np.cross() нужно реже и работает с трёхмерными векторами.

Две вещи стоит держать в голове при переходе на актуальные версии. Первая — NumPy 2.0 добавил np.vecdot(), np.linalg.vector_norm() и np.linalg.cross(), которые явно требуют вектор и не переключаются молча на матричную логику. Вторая — двумерный np.cross() из старых примеров теперь помечен как устаревший.

И главный аргумент в пользу NumPy — не синтаксис, а измеримая разница: ускорение скалярного произведения в 350–450 раз и вчетверо меньший расход памяти на том же миллионе чисел. Понимание векторов при этом переносится дальше почти без изменений: та же математика лежит под эмбеддингами, рекомендациями и поиском по смыслу.