С чего начать
Что такое NumPy?
Сила NumPy в ndarray: однородном n-мерном массиве с непрерывной памятью. Поскольку все элементы одного типа лежат в одном блоке, операции выполняются скомпилированным кодом C/Fortran (векторизация) и работают в 10–100 раз быстрее эквивалентных циклов Python. Почти весь стек научного Python (pandas, scikit-learn, PyTorch, TensorFlow) построен поверх массивов NumPy.
# NumPy: the fundamental package for numerical computing in Python.
# Core data structure: the n-dimensional array (ndarray).
# Key advantages over pure Python lists:
# - Homogeneous, contiguous memory -> fast vectorized ops
# - Broadcasting: operate on arrays of different shapes
# - Rich set of math / linear algebra / FFT / random routines
# - C/Fortran backend -> orders of magnitude faster than Python loops
import numpy as np
print(np.__version__) # e.g. 1.26.0Установка и импорт
np — почти универсальный псевдоним NumPy: все учебники и библиотеки его ожидают, поэтому придерживайтесь его. Если нужна сборка, оптимизированная под конкретный CPU, conda часто поставляет NumPy, связанный с MKL, — это быстрее для линейной алгебры, чем вариант из pip по умолчанию.
# Install NumPy
pip install numpy
# Or with conda
conda install numpy
# The universal convention is to alias as np
import numpy as np
a = np.array([1, 2, 3])
print(a) # [1 2 3]
print(type(a)) # <class 'numpy.ndarray'>Атрибуты ndarray
Знание этих атрибутов — основа отладки кода на NumPy. shape и dtype встречаются чаще всего: shape говорит о структуре, dtype — о занимаемой памяти. itemsize * size = nbytes позволяет оценить расход памяти до выделения огромных массивов.
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
a.ndim # 2 -> number of axes (dimensions)
a.shape # (2, 3) -> tuple of axis sizes
a.size # 6 -> total elements = prod(shape)
a.dtype # int64 -> element type
a.itemsize # 8 -> bytes per element
a.nbytes # 48 -> total bytes = size * itemsize
a.T # shape (3, 2) transposed view
a.flat # flat iterator over all elementsТипы данных (dtype)
Выбор правильного dtype критичен для памяти и корректности. float32 вдвое экономичнее float64 при небольшой потере точности для большинства ML-задач. int8/int16 могут молча переполняться: np.array([200], dtype=np.int8) станет -56. Всегда берите наименьший dtype, который безопасно вмещает ваш диапазон, особенно для больших массивов и embedded-развёртываний.
import numpy as np
# Specifying dtype at creation
a = np.array([1, 2, 3], dtype=np.float32)
b = np.array([1, 2, 3], dtype="float32") # string form works too
# Integer types: int8 int16 int32 int64 (and unsigned uint*)
# Float types: float16 float32 float64 (default)
# Complex: complex64 complex128
# Others: bool, string_, unicode_, object
# Cast an existing array
c = a.astype(np.int32)
# Default int/float match the platform
print(np.dtype(int).itemsize) # 4 or 8
print(np.dtype(float).itemsize) # 8
# Beware overflow:
small = np.array([200], dtype=np.int8) # wraps around!Массив против списка Python
Версия со списковым включением выполняется в интерпретаторе Python (по одному байткоду на элемент), а версия NumPy отправляет работу в один C-цикл по непрерывной памяти. Для численных задач NumPy обычно в 20–100 раз быстрее и расходует гораздо меньше памяти (нет Python-объекта на элемент). Списки используйте только для разнородных типов или нечисловых данных.
import numpy as np
import time
# Python list: element-wise multiply needs a loop or comprehension
py_list = list(range(1_000_000))
start = time.perf_counter()
py_sq = [x * 2 for x in py_list]
print("list:", time.perf_counter() - start)
# NumPy: vectorized, runs in C
arr = np.arange(1_000_000)
start = time.perf_counter()
np_sq = arr * 2
print("numpy:", time.perf_counter() - start)
# NumPy is typically 20-100x faster for numeric workloads.
# Lists are heterogeneous & flexible; arrays are homogeneous & fast.Создание массивов
Из структур Python
np.array() превращает списки и кортежи (или любой вложенный итерируемый объект) в ndarray. Глубина вложенности определяет число измерений. Указывайте dtype при создании, чтобы избежать лишнего копирования позже: np.array([1,2,3]) по умолчанию даёт int64 на большинстве платформ, поэтому для float передавайте dtype=float.
import numpy as np
# From a list (1-D)
a = np.array([1, 2, 3])
# From a list of lists (2-D)
b = np.array([[1, 2, 3],
[4, 5, 6]])
# From nested lists (3-D)
c = np.array([[[1, 2], [3, 4]],
[[5, 6], [7, 8]]])
# Specify dtype up front
d = np.array([1, 2, 3], dtype=np.float32)
# From any iterable
e = np.array(range(5)) # [0 1 2 3 4]
f = np.array((1, 2, 3)) # from a tupleВстроенные диапазоны и сетки
Для float предпочитайте linspace, а не arange: шаг arange может дать неточную конечную точку из-за округления с плавающей точкой. meshgrid — стандартный способ строить координатные сетки для 3D-графики, обработки изображений и конечно-разностных вычислений. Используйте np.mgrid / np.ogrid для открытых (экономных по памяти) сеток.
import numpy as np
# arange: like range but returns array (watch float edge!)
np.arange(0, 10, 2) # [0 2 4 6 8]
np.arange(0, 1, 0.1) # may or may not include 1.0 (float!)
# linspace: exactly num points, endpoints included by default
np.linspace(0, 1, 5) # [0. 0.25 0.5 0.75 1. ]
# logspace: 10**start .. 10**stop
np.logspace(0, 3, 4) # [ 1. 10. 100. 1000.]
# Meshgrids for evaluating functions on a grid
x = np.linspace(-2, 2, 5)
y = np.linspace(-2, 2, 5)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2 # 5x5 grid of valuesZeros, ones и константы
zeros/ones/full заранее заполняют буфер; empty пропускает заполнение, поэтому быстрее, когда вы всё равно перезапишете каждый элемент (например, как выходной буфер). eye(k=n) строит единичную матрицу; eye(k=1) сдвигает диагональ вверх. Всегда передавайте dtype в zeros/ones: по умолчанию они дают float64, что тратит память, если вы хотели целые.
import numpy as np
np.zeros((2, 3)) # 2x3 of float64 zeros
np.zeros((2, 3), dtype=int) # 2x3 of int zeros
np.ones((3, 3)) # 3x3 of ones
np.full((2, 2), 7) # 2x2 filled with 7
np.full((2, 2), np.pi) # fill with any constant
# Identity & eye
np.eye(3) # 3x3 identity matrix
np.eye(3, k=1) # identity shifted up by one diagonal
np.diag([1, 2, 3]) # diagonal matrix from a vector
# Empty: uninitialized memory (fastest, but garbage values)
np.empty((2, 2)) # allocate without fillingСлучайные массивы
Используйте np.random.default_rng(seed): современный Generator быстрее, статистически лучше и воспроизводим. Устаревший API np.random.rand/randn/seed использует глобальное состояние и не рекомендуется в новом коде. Всегда передавайте явный seed для воспроизводимости в экспериментах и тестах; без него результаты различаются между запусками.
import numpy as np
rng = np.random.default_rng(seed=42) # modern Generator (NumPy >= 1.17)
rng.random((2, 3)) # uniform in [0, 1), shape (2, 3)
rng.standard_normal((2, 3)) # standard normal (mean 0, std 1)
rng.normal(100, 15, size=5) # normal(mu=100, sigma=15)
rng.uniform(0, 10, size=5) # uniform in [low, high)
rng.integers(0, 10, size=5) # random ints in [low, high)
# Reproducibility: always pass a seed
rng2 = np.random.default_rng(42)
print(rng2.random(3)) # same every run
# Legacy API (still common but prefer default_rng)
# np.random.rand(2, 3) # uniform [0,1)
# np.random.randn(2, 3) # standard normalКопирование существующих массивов
Срезы и .view() создают представления, разделяющие память: изменение одного меняет другое. Используйте .copy(), когда нужен независимый массив. Reshape, ravel и transpose тоже по возможности возвращают представления, поэтому всегда делайте .copy() перед изменением, если нужен оригинал. Забыть об этом — одна из самых частых ошибок в NumPy.
import numpy as np
a = np.array([1, 2, 3])
# View (shares memory!) - shape change only
v = a.view()
v[0] = 99
print(a) # [99 2 3] <- a is mutated!
# Deep copy (independent)
b = a.copy()
b[0] = 0
print(a) # [99 2 3] <- a unchanged
# np.array defaults to copying
c = np.array(a)
c is a # False
# Repeat / tile to expand arrays
np.repeat([1, 2, 3], 2) # [1 1 2 2 3 3]
np.tile([1, 2, 3], 2) # [1 2 3 1 2 3]Индексация и срезы
Базовые срезы
Срезы следуют соглашению Python [start:stop:step], где stop не включается. Критично: срезы NumPy — это представления, они разделяют память с источником, поэтому изменение среза меняет оригинал. Это сделано намеренно (экономит память), но часто становится источником багов. Используйте .copy(), когда нужен независимый массив.
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a[0] # 0 (scalar)
a[-1] # 9 (last element)
a[2:5] # [2 3 4] start:stop (stop excluded)
a[:5] # [0 1 2 3 4]
a[5:] # [5 6 7 8 9]
a[::2] # [0 2 4 6 8] step=2
a[::-1] # [9 8 7 6 5 4 3 2 1 0] reversed
a[1:7:2] # [1 3 5] start:stop:step
# Slices return VIEWS (not copies) -> editing changes the original
b = a[2:5]
b[0] = 99
print(a[2]) # 99 <- a was modified!Многомерная индексация
Пишите a[i, j], а не a[i][j]: форма с запятой — одна операция и быстрее. a[:, j] выбирает весь столбец. Используйте ... (Ellipsis) для массивов от 3 измерений, чтобы обозначить «все оставшиеся оси» и не писать множество двоеточий. Каждый срез возвращает представление.
import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
a[1, 2] # 6 (row 1, col 2) - equivalent to a[1][2] but faster
a[0] # [1 2 3] (row 0)
a[0, :] # [1 2 3] (row 0, all cols)
a[:, 1] # [2 5 8] (all rows, col 1)
a[1:3, 0:2] # [[4 5]
# [7 8]] rows 1-2, cols 0-1
a[-1] # [7 8 9] last row
a[:, -1] # [3 6 9] last column
# ... (ellipsis) selects any remaining full axes
b = np.zeros((2, 3, 4))
b[..., 0] # shape (2, 3) - last axis indexed, others kept
b[1, ...] # shape (3, 4) - first axis indexedБулева (масочная) индексация
Булева индексация всегда возвращает КОПИЮ, никогда представление, — можно безопасно изменять. Комбинируйте маски через & | ~ (НЕ через and/or: они работают с истинностью массива и вызывают ошибку). np.where возвращает индексы; np.where(cond, x, y) — векторизованный тернарный оператор. Это рабочая лошадка фильтрации и условной логики.
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
# Build a boolean mask
mask = a > 3
# [False False False True True True]
a[mask] # [4 5 6] (select elements where mask is True)
a[a > 3] # same, in one expression
a[(a > 2) & (a < 6)] # [3 4 5] combine with & (and), | (or), ~ (not)
# Modify via mask
a[a > 3] = 0 # set all matching elements
a[a == 0] = -1 # conditional assignment
# Count matching elements
(a > 3).sum() # 3 (True == 1)
np.count_nonzero(a > 3)
# np.where: positions where condition is True
np.where(a > 3) # (array([3, 4, 5]),) indicesFancy-индексация (массивы индексов)
Fancy-индексация (массивом целых) тоже возвращает копию, никогда представление. При индексации 2-D массива двумя массивами индексов b[rows, cols] они сопоставляются поэлементно (давая точки), а НЕ декартово произведение. Для произведения используйте np.ix_(rows, cols). Это различие — частый источник путаницы.
import numpy as np
a = np.array([10, 20, 30, 40, 50])
# Index with a list/array of indices
a[[0, 2, 4]] # [10 30 50]
a[np.array([0, 2, 4])] # same
# Indices can repeat
a[[0, 0, 1]] # [10 10 20]
# Negative indices work
a[[-1, -2]] # [50 40]
# 2-D fancy indexing
b = np.arange(12).reshape(3, 4)
rows = np.array([0, 2])
cols = np.array([1, 3])
b[rows, cols] # [1 11] pairs (0,1) and (2,3)
# Mix a slice and an index array
b[1:, [0, 2]] # rows 1-2, cols 0 and 2
# np.take: same as fancy indexing, more flexible
np.take(a, [0, 2]) # [10 30]Присваивание по индексу и np.where
np.where(cond, x, y) — векторизованный if-else, крайне часто используется для построения массивов по условиям. С одним аргументом он возвращает индексы, где условие истинно. np.select обрабатывает несколько взаимоисключающих условий, а np.clip — чистый способ ограничить значения без явных масок.
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
# Conditional assignment with a mask
a[a % 2 == 0] = -1 # even -> -1: [1 -1 3 -1 5 -1]
# np.where(cond, x, y): vectorized ternary
b = np.where(a > 3, "big", "small")
# ['small' 'small' 'small' 'big' 'big' 'big']
# np.where with one argument -> indices of True
idx = np.where(a == -1)
# (array([1, 3, 5]),)
# np.select: multiple conditions, multiple choices
conds = [a < 3, a > 3, a == 3]
choices = ["low", "high", "mid"]
np.select(conds, choices, default="ok")
# np.clip: clamp values to a range
np.clip(a, 0, 4) # values < 0 -> 0, > 4 -> 4Изменение формы и манипуляции
reshape и вывод -1
reshape меняет форму, сохраняя общий размер. Используйте -1 для одного измерения, и NumPy выведет его из размера: допускается только одна -1. reshape обычно возвращает представление (без копирования данных), поэтому изменение преобразованного массива меняет оригинал. Общее число элементов должно оставаться неизменным, иначе ValueError.
import numpy as np
a = np.arange(12) # [0 1 2 ... 11], shape (12,)
# reshape to (3, 4)
b = a.reshape(3, 4)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# Use -1 to infer one dimension
a.reshape(2, -1) # (2, 6) - -1 means "figure it out"
a.reshape(-1, 3) # (4, 3)
a.reshape(2, -1, 2) # (2, 3, 2) only one -1 allowed
# Total size must match -> ValueError otherwise
# a.reshape(5, 3) # 5*3 = 15 != 12
# reshape returns a view when possible (no copy)
b[0, 0] = 99
print(a[0]) # 99 <- a was modifiedFlatten и ravel
ravel() возвращает представление (быстро, разделяет память), а flatten() всегда возвращает копию (безопасно, но медленнее и тратит в 2 раза больше памяти). Берите ravel, когда нужно просто итерироваться, и flatten, когда буд ете изменять результат, не затрагивая оригинал. Аргумент order важен при взаимодействии с кодом Fortran или MATLAB.
import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6]])
# ravel: returns a VIEW (C order by default) - efficient
a.ravel() # [1 2 3 4 5 6]
a.ravel(order='F') # [1 4 2 5 3 6] Fortran (column) order
# flatten: always returns a COPY - safe to mutate
flat = a.flatten()
flat[0] = 99
print(a[0, 0]) # 1 <- a unchanged
# Order conventions:
# 'C' (default): last axis varies fastest (row-major)
# 'F': first axis varies fastest (column-major)
# 'A': Fortran order if array is F-contiguous, else C
# 'K': preserve memory orderТранспонирование и перестановка осей
Транспонирование — просто представление, меняющее порядок чтения памяти: данные не копируются, это дёшево, но результат может быть не непрерывным. Для 2-D массивов достаточно .T; для 3+ измерений используйте transpose(axis_order), swapaxes или moveaxis, чтобы точно управлять осями. Операции с не непрерывными массивами могут быть медленнее, поэтому в горячих циклах помогает np.ascontiguousarray.
import numpy as np
a = np.arange(12).reshape(3, 4)
a.T # shape (4, 3) transpose (2-D)
a.transpose() # same
# For 3+ dimensions, specify axis order
b = np.arange(24).reshape(2, 3, 4)
b.transpose(1, 0, 2) # shape (3, 2, 4) axes reordered
b.swapaxes(0, 1) # shape (3, 2, 4) swap two axes
b.T # shape (4, 3, 2) reverse all axes
# Move axes to new positions
np.moveaxis(b, 0, -1) # shape (3, 4, 2)
# All of these return VIEWS (no data copy)Объединение массивов
stack добавляет НОВУЮ ось (превращает два 1-D массива в 2-D); concatenate соединяет по СУЩЕСТВУЮЩЕЙ оси. vstack/hstack/dstack — удобные обёртки для 1-D и 2-D. Для сложных раскладок np.block принимает вложенные списки массивов, как при сборке матрицы из блоков. Все функции объединения создают новые массивы (копии).
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# Stack along a NEW axis
np.stack([a, b]) # shape (2, 3) - default axis=0
np.stack([a, b], axis=1) # shape (3, 2) column stack
# Concatenate along an EXISTING axis
np.concatenate([a, b]) # [1 2 3 4 5 6]
np.vstack([a, b]) # shape (2, 3) vertical
np.hstack([a, b]) # [1 2 3 4 5 6] horizontal
np.dstack([a, b]) # shape (1, 3, 2) depth
# 2-D arrays
A = np.ones((2, 2))
B = np.zeros((2, 2))
np.hstack([A, B]) # shape (2, 4)
np.vstack([A, B]) # shape (4, 2)
# np.block: build from nested blocks
np.block([[A, B], [B, A]]) # shape (4, 4)Разбиение массивов
split требует кусков одинакового размера (иначе ValueError), а array_split допускает неравномерное деление — удобно, когда N не делится нацело. vsplit/hsplit/dsplit — помощники для конкретных осей, эквивалентные np.split(arr, n, axis=...). Все возвращают списки представлений в исходный массив, поэтому экономны по памяти.
import numpy as np
a = np.arange(12)
# Split into equal parts (must divide evenly)
np.split(a, 3) # [array([0,1,2,3]), array([4,5,6,7]), array([8,9,10,11])]
# Split at specific indices
np.split(a, [3, 5]) # [array([0,1,2]), array([3,4]), array([5,6,7,8,9,10,11])]
# 2-D
b = np.arange(16).reshape(4, 4)
np.vsplit(b, 2) # split along rows -> 2 arrays of shape (2, 4)
np.hsplit(b, 2) # split along cols -> 2 arrays of shape (4, 2)
# array_split: allows uneven division
np.array_split(np.arange(10), 3) # sizes [4, 3, 3] - no error
# dsplit: split along depth (axis 2)
c = np.arange(24).reshape(2, 2, 6)
np.dsplit(c, 3) # 3 arrays of shape (2, 2, 2)Вещание (broadcasting)
Правила вещания
Вещание позволяет комбинировать массивы разных форм, виртуально растягивая оси размера 1, — данные на самом деле не копируются. Правило: сравнивайте формы справа налево; каждая ось должна быть равной или одна из них должна быть 1 (или отсутствовать). Это делает код на NumPy лаконичным (без явных циклов), но также частым источником незаметных ошибок форм — всегда проверяйте shape, если что-то выглядит не так.
import numpy as np
# Broadcasting: operate on arrays of different shapes without copying.
# Two shapes are compatible if, for each trailing axis, they are
# equal OR one of them is 1.
# Scalar broadcast to any array
a = np.array([1, 2, 3])
a + 10 # [11 12 13] 10 treated as shape ()
# 1-D with 2-D
A = np.ones((3, 4))
row = np.array([10, 20, 30, 40])
A + row # row (4,) broadcast to (3, 4) -> added to each row
col = np.array([[100], [200], [300]]) # shape (3, 1)
A + col # col broadcast across columns -> added to each column
# Incompatible shapes raise ValueError
# A + np.array([1, 2, 3]) # (3,4) vs (3,) -> errorДобавление осей для вещания
np.newaxis (псевдоним None) вставляет ось размера 1 — стандартный приём, чтобы массив вёлся так, как нужно. Добавление оси столбца (a[:, None]) и оси строки (a[None, :]) позволяет вычислять внешние произведения, попарные разности и многое другое без циклов. np.expand_dims — именованный эквивалент для читаемости.
import numpy as np
a = np.array([1, 2, 3]) # shape (3,)
b = np.array([10, 20, 30, 40]) # shape (4,)
# a + b would fail (3,) vs (4,)
# Insert a new axis so shapes become (3, 1) and (4,) -> broadcasts to (3, 4)
a_col = a[:, np.newaxis] # shape (3, 1) - same as a.reshape(-1, 1)
b_row = b[np.newaxis, :] # shape (1, 4)
outer = a_col + b_row # shape (3, 4) outer sum
# [[11 21 31 41]
# [12 22 32 42]
# [13 23 33 43]]
# np.newaxis / None are equivalent
a[:, None] # same as a[:, np.newaxis]
# np.expand_dims is the explicit function form
np.expand_dims(a, axis=1) # shape (3, 1)Внешние произведения и попарные операции
Добавление новой оси для превращения 1-D операции в 2-D вычисление внешнего типа — ключевая идиома векторизованного NumPy. a[:, None] - b[None, :] вычисляет все попарные разности без циклов — гораздо быстрее вложенных циклов Python. Этот паттерн питает матрицы расстояний, вычисления ядер и сеточные операции.
import numpy as np
a = np.array([1, 2, 3])
b = np.array([10, 20, 30, 40])
# Outer product (3,) x (4,) -> (3, 4)
np.outer(a, b)
# [[10 20 30 40]
# [20 40 60 80]
# [30 60 90 120]]
# Manual outer via broadcasting
a[:, None] * b[None, :] # same as np.outer(a, b)
# Pairwise difference: (4,) - (3,) -> (4, 3) or (3, 4)?
diff = b[:, None] - a[None, :] # shape (4, 3): diff[i, j] = b[i] - a[j]
# Pairwise equality (used in set ops, distance)
x = np.array([1, 2, 3, 4])
y = np.array([2, 4, 6])
x[:, None] == y[None, :] # shape (4, 3) boolean matrix
# Add a constant vector to each row of a matrix
M = np.zeros((5, 3))
v = np.array([1, 2, 3])
M + v # broadcasts v to every rowЧастые ловушки вещания
1-D массив формы (N,) вещается как СТРОКА относительно 2-D массива — это НЕ вектор-столбец. Чтобы сделать его столбцом, нужно добавить ось: a[:, None]. Остерегайтесь нежелательного вещания при добавлении новых осей: два массива (1000, 1000) могут раздуться в промежуточный (1000, 1000, 1000) (8 ГБ) и уронить программу. Всегда проверяйте формы через .shape перед большими вычислениями.
import numpy as np
# Pitfall 1: (N,) is NOT a row or column vector - it has no axis direction
a = np.array([1, 2, 3])
M = np.ones((3, 3))
M + a # OK: (3,3) + (3,) -> a broadcast as a ROW
M + a[:, None] # OK: a as a COLUMN
# Pitfall 2: accidentally broadcasting when you wanted element-wise
x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
x + y # [11 22 33] element-wise (both (3,))
x[:, None] + y # (3,3) matrix - probably not what you wanted!
# Pitfall 3: shape (1,) vs () - both broadcast but mean different things
np.array([5]).shape # (1,)
np.array(5).shape # () - 0-D, broadcasts to ANYTHING
# Pitfall 4: memory blow-up from over-broadcasting
# Big arrays broadcast together can produce enormous intermediates
A = np.ones((1000, 1000))
B = np.ones((1000, 1000))
(A * B).sum() # OK - intermediate is 8MB
# A[:, None, :] * B[None, :, :] # (1000,1000,1000) = 8GB! crashВещание с np.broadcast_to
np.broadcast_to позволяет явно создать вещаемое представление — полезно, когда API требует конкретную форму, но вы хотите избежать затрат памяти на полную копию. Результат доступен только для чтения, потому что базовые данные меньше, чем подразумевает форма. np.broadcast_arrays удобен, когда нужно итерироваться по нескольким массивам так, будто у них одинаковая форма.
import numpy as np
# np.broadcast_to: explicit view of an array broadcast to a new shape
a = np.array([1, 2, 3]) # shape (3,)
b = np.broadcast_to(a, (4, 3)) # shape (4, 3) - VIEW, no copy
# [[1 2 3]
# [1 2 3]
# [1 2 3]
# [1 2 3]]
b[0, 0] = 99 # ERROR: broadcast_to returns read-only view
# np.broadcast_arrays: broadcast several arrays together (as views)
x = np.array([1, 2, 3]) # (3,)
y = np.array([[10], [20]]) # (2, 1)
bx, by = np.broadcast_arrays(x, y)
bx.shape # (2, 3)
by.shape # (2, 3)
# np.broadcast: low-level iterator object
b = np.broadcast(x, y)
b.shape # (2, 3)
b.index # current position in the iteration
b.iters # list of iterators over each inputМатематические операции
Поэлементная арифметика
Операторы NumPy (+, *, **) соответствуют ufunc (np.add, np.multiply, np.power) и работают поэлементно. Оператор * поэлементный, а НЕ матричное умножение: для умножения матриц используйте @ или np.dot. Операторы на месте (+=, *=) экономят память, переиспользуя буфер массива; им нужны совпадающие dtype и форма (после вещания).
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
a + b # [11 22 33 44]
a - b # [-9 -18 -27 -36]
a * b # [10 40 90 160] element-wise (NOT matrix product)
a / b # [0.1 0.1 0.1 0.1] always float
a // b # [0 0 0 0] floor division
a ** 2 # [1 4 9 16] power
a % 2 # [1 0 1 0] modulo
-a # [-1 -2 -3 -4] negation
# In-place ops (modify a, save memory)
a += 10
a *= 2
# Scalar ops broadcast
a + 100 # [102 104 106 108]
# Universal functions (ufuncs) - same operations as function form
np.add(a, b)
np.multiply(a, b)
np.power(a, 2)Универсальные функции (ufunc)
ufunc — векторизованные функции, работающие поэлементно в скомпилированном C, — гораздо быстрее применения модуля math в цикле. np.maximum (поэлементный максимум двух массивов) отличается от np.max (максимум одного массива). Используйте np.fmax, чтобы игнорировать NaN в сравнениях. Все ufunc поддерживают out= для записи в заранее выделенный буфер в горячих циклах без аллокаций.
import numpy as np
a = np.array([-1.5, 0.0, 1.5, 2.5])
# Math ufuncs
np.abs(a) # [1.5 0. 1.5 2.5]
np.sqrt(np.abs(a))
np.exp(a) # e^a
np.log(np.abs(a) + 1)
np.log2(a + 5)
np.log10(a + 5)
# Rounding
np.round(a) # [-2. 0. 2. 2.]
np.floor(a) # [-2. 0. 1. 2.]
np.ceil(a) # [-1. 0. 2. 3.]
np.trunc(a) # [-1. 0. 1. 2.] truncate toward zero
# Trigonometry (radians)
np.sin(np.pi/2) # 1.0
np.cos(0) # 1.0
np.degrees(np.pi) # 180.0
np.radians(180) # 3.14159...
# Comparison ufuncs
np.greater(a, 0) # [False False True True]
np.maximum(a, 0) # clip negatives to 0 (element-wise max)
np.minimum(a, 0)Операции редукции
Редукции (sum, mean, max, min, std) по умолчанию работают по всему массиву или по одной оси через axis=. axis=0 сворачивает строки (вниз), axis=1 — столбцы (поперёк). keepdims=True сохраняет свёрнутую ось размером 1 — необходимо для вещания результата обратно. Всегда передавайте dtype=np.float64 при суммировании целых, которые могут переполниться.
import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6]])
# Global reductions
a.sum() # 21
a.prod() # 720
a.min(), a.max()
a.mean() # 3.5
a.std(), a.var()
a.argmin(), a.argmax() # indices of min/max (flattened)
# Axis-wise reductions
a.sum(axis=0) # [5 7 9] sum down each column
a.sum(axis=1) # [6 15] sum across each row
a.min(axis=1) # [1 4] min of each row
a.cumsum(axis=0) # cumulative sum down columns
a.cumprod(axis=1) # cumulative product across rows
# Keep dimensions
a.sum(axis=0, keepdims=True) # shape (1, 3) - keeps the axis
# Specify dtype for accumulation (avoid overflow!)
a.sum(dtype=np.float64)
# NaN-aware versions
b = np.array([1.0, np.nan, 3.0])
np.nansum(b) # 4.0 treats NaN as 0Накопительные и сканирующие операции
cumsum / cumprod сохраняют форму входа и возвращают накопительные итоги. diff — дискретная производная и обратная операция к cumsum. Остерегайтесь переполнения в cumsum: накопление int32 может незаметно переполниться; переходите на int64 или float. Метод .accumulate у любой ufunc (np.maximum.accumulate) даёт накопительную редукцию.
import numpy as np
a = np.array([1, 2, 3, 4, 5])
# Cumulative sum and product
np.cumsum(a) # [ 1 3 6 10 15]
np.cumprod(a) # [ 1 2 6 24 120]
# 2-D: specify axis
b = np.array([[1, 2], [3, 4]])
np.cumsum(b, axis=0) # [[1 2]
# [4 6]]
np.cumsum(b, axis=1) # [[1 3]
# [3 7]]
# Differences (inverse of cumulative sum)
np.diff(a) # [1 1 1 1] a[i+1] - a[i]
np.diff(a, n=2) # second-order diff [0 0 0]
# Edge: cumsum on integers can overflow silently
big = np.array([2**30, 2**30, 2**30], dtype=np.int32)
np.cumsum(big) # wraps around - use int64 or float!
# Cumulative max / min
np.maximum.accumulate(a) # [1 2 3 4 5]
np.minimum.accumulate(a) # [1 1 1 1 1]Сравнения и логика
Используйте & | ~ для булевых массивов (не and/or: они требуют единственного значения истинности). np.any / np.all сворачивают булев массив в одно True/False, что полезно в утверждениях и условиях. Никогда не сравнивайте float через ==: np.isclose или np.allclose с подходящими допусками (atol/rtol) обрабатывают округление. allclose — стандарт для сравнения массивов float.
import numpy as np
a = np.array([1, 2, 3, 4, 5])
# Element-wise comparisons return boolean arrays
a > 3 # [False False False True True]
a == 3 # [False False True False False]
a != 3
np.greater(a, 3)
# Logical ops on boolean arrays
b = (a > 2)
c = (a < 5)
np.logical_and(b, c) # [False False True True False]
np.logical_or(b, c)
np.logical_not(b)
np.logical_xor(b, c)
# Array-level truth testing
np.any(a > 4) # True
np.all(a > 0) # True
np.all(a > 0, axis=0) # per-axis
(a == 3).any() # True
# np.isclose for float comparisons
np.isclose(0.1 + 0.2, 0.3) # True (handles float error)
np.allclose([0.1, 0.2], [0.1, 0.2 + 1e-9], atol=1e-8) # TrueСтатистические операции
Базовая статистика
var/std по умолчанию используют ddof=0 (генеральная совокупность), а pandas — ddof=1 (выборка), что часто даёт расхождения. Для выборочной статистики используйте ddof=1. np.percentile принимает значения 0–100, np.quantile — 0.0–1.0. np.corrcoef возвращает полную матрицу корреляций; берите [0, 1] для скалярного коэффициента между двумя массивами.
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
a.mean() # 5.5 arithmetic mean
a.median() if hasattr(a, 'median') else np.median(a) # 5.5
a.var() # 8.25 variance (population, ddof=0)
a.std() # 2.87 standard deviation
a.min(), a.max() # 1, 10
a.ptp() # 9 peak-to-peak = max - min
# Sample vs population variance
a.var(ddof=1) # sample variance (divide by N-1, like pandas default)
# Percentiles & quantiles
np.percentile(a, 50) # 5.5 median
np.percentile(a, [25, 50, 75]) # [3.25 5.5 7.75] quartiles
np.quantile(a, 0.5) # 5.5 same as percentile / 100
# Correlation
x = np.array([1, 2, 3, 4])
y = np.array([2, 4, 5, 4])
np.corrcoef(x, y) # 2x2 correlation matrixГистограммы и биннинг
np.histogram возвращает счётчики и границы (границ на один элемент больше, чем корзин). density=True даёт плотность вероятности (площадь = 1) вместо сырых счётчиков. np.histogram2d строит 2-D гистограмму для тепловых карт и совместных распределений. np.digitize отображает значения в индексы корзин; np.bincount — быстрый способ считать вхождения целых.
import numpy as np
data = np.random.default_rng(42).standard_normal(1000)
# 1-D histogram
counts, edges = np.histogram(data, bins=10)
# counts: array of element counts per bin
# edges: array of bin edge positions (length = bins + 1)
# Custom bin edges
np.histogram(data, bins=[-3, -1, 0, 1, 3])
# Density (integrates to 1) vs counts
np.histogram(data, bins=20, density=True)
# 2-D histogram (for heatmaps)
x = np.random.default_rng(1).standard_normal(1000)
y = np.random.default_rng(2).standard_normal(1000)
H, xedges, yedges = np.histogram2d(x, y, bins=20)
# Digitize: which bin does each value fall into?
bins = [-2, -1, 0, 1, 2]
indices = np.digitize(data, bins) # array of bin indices (1-based)
# Bincount: count occurrences of each non-negative int
np.bincount(np.array([0, 1, 1, 3, 3, 3])) # [1 2 0 3]Сортировка и порядковые статистики
argsort — ключ к ранжированию: он возвращает индексы, которые отсортировали бы массив, позволяя переупорядочить другой массив так же. np.partition гораздо быстрее полной сортировки, когда нужны только top-k элементы (O(n) против O(n log n)). np.unique возвращает отсортированные уникальные значения; return_counts=True даёт сводку в духе гистограммы.
import numpy as np
a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
# Sorting
np.sort(a) # [1 1 2 3 4 5 6 9] returns a copy
a.sort() # in-place sort (modifies a)
np.sort(a)[::-1] # descending
np.argsort(a) # indices that would sort a (no copy)
# 2-D sorting along axis
b = np.array([[3, 1, 2], [6, 5, 4]])
np.sort(b, axis=0) # sort down each column
np.sort(b, axis=1) # sort across each row (default)
# Partial sorting: top-k smallest (no full sort)
np.partition(a, 3) # 3 smallest first (unordered), rest after
np.argpartition(a, 3) # indices of partition
# k-th smallest element (selection algorithm)
np.partition(a, 2)[2] # 3rd smallest (index 2)
# unique values (sorted)
np.unique([1, 2, 1, 3, 2]) # [1 2 3]
np.unique(a, return_counts=True) # values and countsКовариация и корреляция
np.cov по умолчанию трактует каждую СТРОКУ как переменную (rowvar=True), в отличие от pandas, который использует столбцы. Чтобы соответствовать pandas, передайте rowvar=False или транспонируйте данные. np.corrcoef возвращает полную матрицу; берите [0, 1] для скалярного коэффициента между двумя переменными. Диагональ ковариационной матрицы — дисперсия каждой переменной.
import numpy as np
# Sample data: 3 variables, 5 observations
data = np.array([[1, 2, 3, 4, 5],
[2, 4, 1, 3, 5],
[5, 4, 3, 2, 1]], dtype=float)
# Covariance matrix (3x3)
# Each ROW is a variable, so set rowvar=False to treat COLUMNS as variables
cov = np.cov(data, rowvar=True) # 3x3 covariance between rows
# Diagonal = variance of each variable
# Off-diagonal = covariance between pairs
# Correlation matrix
corr = np.corrcoef(data) # 3x3, values in [-1, 1]
# Correlation between two specific variables
np.corrcoef(data[0], data[1])[0, 1] # scalar
# Weighted covariance: compute manually
weights = np.array([1, 1, 1, 2, 2])
mean = np.average(data, axis=1, weights=weights, keepdims=True)
centered = data - mean
weighted_cov = (centered * weights) @ centered.T / weights.sum()
# Pearson correlation coefficient (manual)
def pearson(x, y):
xm, ym = x - x.mean(), y - y.mean()
return np.dot(xm, ym) / (np.sqrt((xm**2).sum()) * np.sqrt((ym**2).sum()))Статистика с учётом NaN
Стандартные редукции распространяют NaN (любой NaN отравляет результат), что редко нужно. Используйте nan*-варианты (nanmean, nansum, nanstd), чтобы игнорировать NaN. nan_to_num заменяет NaN и бесконечности конечными значениями — идеально для очистки данных перед вычислениями. Для тяжёлой работы с NaN pandas часто удобнее чистого NumPy.
import numpy as np
a = np.array([1.0, 2.0, np.nan, 4.0, 5.0])
# Standard functions propagate NaN
a.mean() # nan
a.sum() # nan
# NaN-aware equivalents
np.nanmean(a) # 3.0 ignores NaN
np.nansum(a) # 12.0
np.nanstd(a)
np.nanmedian(a)
np.nanvar(a)
np.nanmin(a), np.nanmax(a)
np.nanpercentile(a, 50)
# Count non-NaN elements
np.count_nonzero(~np.isnan(a)) # 4
# Find NaN positions
np.isnan(a) # [False False True False False]
np.where(np.isnan(a)) # (array([2]),)
# Replace NaN with a value (imputation)
np.nan_to_num(a, nan=0.0) # replace NaN with 0
np.where(np.isnan(a), 0, a) # same, more explicit
a_filled = np.copy(a)
a_filled[np.isnan(a)] = np.nanmean(a) # fill with mean
# Check if any NaN
np.isnan(a).any() # TrueЛинейная алгебра (numpy.linalg)
Умножение матриц
Используйте @ для умножения матриц: это современный оператор (Python 3.5+), понятнее .dot() и работает для батчевых (N-D) операций. Оператор * поэлементный (Адамар), что часто путает людей из MATLAB. np.matmul (@) отличается от np.dot в обработке 1-D и поведении при укладке N-D массивов.
import numpy as np
A = np.array([[1, 2],
[3, 4]])
B = np.array([[5, 6],
[7, 8]])
# Matrix product (2-D)
A @ B # [[19 22]
# [43 50]] preferred operator (Py 3.5+)
A.dot(B) # same, older method
np.dot(A, B) # same for 2-D
# 1-D: dot is inner product
v = np.array([1, 2, 3])
w = np.array([4, 5, 6])
v @ w # 32 (1*4 + 2*5 + 3*6)
np.dot(v, w) # 32
# Mixed 1-D and 2-D
v = np.array([1, 2])
A @ v # [5 11] matrix-vector product
# Batched matmul (3-D)
X = np.random.rand(10, 3, 4) # 10 matrices of shape (3, 4)
Y = np.random.rand(10, 4, 2)
(X @ Y).shape # (10, 3, 2)
# Element-wise product (Hadamard) - NOT matrix product
A * B # [[5 12]
# [21 32]]Разложения (LU, QR, SVD)
SVD — самое устойчивое разложение и работает для любой матрицы: используйте его при сомнениях. Собственное разложение работает только для квадратных матриц и может быть численно неустойчивым для дефектных. Cholesky — самое быстрое для симметричных положительно определённых матриц (обычных в ковариациях и оптимизации). QR полезен для наименьших квадратов и ортогонализации.
import numpy as np
A = np.array([[4, 3],
[6, 3]])
# SVD: A = U @ diag(s) @ Vt
U, s, Vt = np.linalg.svd(A)
# U: (2,2) left singular vectors
# s: (2,) singular values (sorted descending)
# Vt: (2,2) right singular vectors (already transposed)
# Reconstruct A from SVD
A_reconstructed = U @ np.diag(s) @ Vt
np.allclose(A, A_reconstructed) # True
# QR decomposition: A = Q @ R
Q, R = np.linalg.qr(A)
# Q: orthonormal columns
# R: upper triangular
# Cholesky (for symmetric positive-definite matrices)
S = A @ A.T # symmetric positive-definite
L = np.linalg.cholesky(S)
np.allclose(S, L @ L.T) # True
# Eigen-decomposition (square matrices)
w, V = np.linalg.eig(A)
# w: eigenvalues
# V: eigenvectors as columns
# Eigenvalues only (faster)
np.linalg.eigvals(A)Решение линейных систем и обратная матрица
Всегда предпочитайте np.linalg.solve вычислению обратной матрицы: это быстрее, численно устойчивее и избегает ловушек почти вырожденных матриц. Обратная матрица на практике нужна редко; если вы пишете inv(A) @ b, замените на solve(A, b). pinv обрабатывает прямоугольные и вырожденные матрицы через SVD. Проверяйте cond(A): большое число обусловленности (>1e10) означает численную плохую обусловленность системы.
import numpy as np
A = np.array([[3, 2],
[1, 4]])
b = np.array([7, 6])
# Solve Ax = b (preferred - no explicit inverse)
x = np.linalg.solve(A, b) # [1.6 1.1]
np.allclose(A @ x, b) # True
# Multiple right-hand sides
B = np.array([[7, 1], [6, 2]]) # 2x2
X = np.linalg.solve(A, B) # 2x2 solution matrix
# Inverse (avoid if you only need to solve Ax=b)
A_inv = np.linalg.inv(A)
A_inv @ b # same result as solve, but slower & less stable
# Pseudo-inverse (works for non-square / singular matrices)
A_pinv = np.linalg.pinv(A) # Moore-Penrose pseudo-inverse
# Determinant
np.linalg.det(A) # 10.0
# Matrix rank
np.linalg.matrix_rank(A) # 2
# Condition number (large = ill-conditioned)
np.linalg.cond(A) # ~1.9Нормы и операции с векторами
norm по умолчанию использует L2 для векторов и Frobenius для матриц — в продакшен-коде явно указывайте ord для ясности. ord=1 даёт манхэттенское (такси) расстояние, ord=np.inf — чебышёвское (максимум модуля). Векторное произведение работает только для 3-D векторов. Для попарных расстояний между многими точками scipy.spatial.distance.cdist быстрее цикла Python по norm.
import numpy as np
v = np.array([3, 4])
# Vector norms
np.linalg.norm(v) # 5.0 L2 (Euclidean) - default
np.linalg.norm(v, ord=1) # 7.0 L1 (sum of |x|)
np.linalg.norm(v, ord=np.inf) # 4.0 L-infinity (max |x|)
# Matrix norms
A = np.array([[1, 2], [3, 4]])
np.linalg.norm(A) # Frobenius norm (default for matrices)
np.linalg.norm(A, ord='fro')
np.linalg.norm(A, ord=2) # spectral norm (largest singular value)
np.linalg.norm(A, ord=np.inf) # max row sum
# Normalizing a vector (unit vector)
v / np.linalg.norm(v)
# Distance between two vectors
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
np.linalg.norm(a - b) # Euclidean distance
np.linalg.norm(a - b, ord=1) # Manhattan distance
# Outer product, cross product
np.cross([1, 0, 0], [0, 1, 0]) # [0 0 1] (3-D only)
np.outer([1, 2], [10, 20, 30]) # (2, 3)Наименьшие квадраты и регрессия
np.linalg.lstsq решает задачи наименьших квадратов, не формируя нормальные уравнения (устойчивее). Он возвращает решение, остатки, ранг и сингулярные значения — полезно для диагностики задач с недостаточным рангом. Для полиномиальной подгонки polyfit + poly1d дают удобный API, но остерегайтесь полиномов высокой степени (численная неустойчивость). В серьёзной работе используйте numpy.polynomial.Polynomial ради лучшей обусловленности.
import numpy as np
# Linear least squares: solve Ax = b for over-determined A (more rows than cols)
# Minimizes ||Ax - b||^2
A = np.array([[1, 1],
[1, 2],
[1, 3],
[1, 4]]) # design matrix (4x2)
b = np.array([6, 5, 7, 10]) # observations
x, residuals, rank, sv = np.linalg.lstsq(A, b, rcond=None)
# x: best-fit parameters [intercept, slope] = [3.5, 1.4]
# residuals: sum of squared errors
# rank: effective rank of A
# sv: singular values of A
# Polynomial fitting (least squares under the hood)
x_data = np.array([0, 1, 2, 3, 4])
y_data = np.array([1, 3, 7, 13, 21])
coeffs = np.polyfit(x_data, y_data, deg=2) # quadratic fit
# coeffs[0]*x^2 + coeffs[1]*x + coeffs[2]
# Evaluate polynomial
poly = np.poly1d(coeffs)
poly(2.5) # predict y at x=2.5
# Polynomial roots (zeros)
np.roots([1, -3, 2]) # roots of x^2 - 3x + 2 = 0 -> [2, 1]Случайные числа
Современный Generator (default_rng)
np.random.default_rng — современный рекомендуемый API. Он быстрее устаревших функций np.random.*, обладает лучшими статистическими свойствами и использует явные объекты Generator (без скрытого глобального состояния), что сильно упрощает воспроизводимость и параллелизм. Всегда передавайте явный seed для воспроизводимых исследований и тестов.
import numpy as np
# Create a Generator with a seed (modern API, NumPy >= 1.17)
rng = np.random.default_rng(seed=42)
# Uniform [0, 1) floats
rng.random() # scalar
rng.random(size=5) # 1-D array of 5
rng.random((3, 4)) # 3x4 array
# Standard normal (mean 0, std 1)
rng.standard_normal(5)
rng.standard_normal((2, 3))
# Integers in [low, high)
rng.integers(0, 10, size=5) # 5 random ints in [0, 10)
rng.integers(1, 7, size=(2, 3), endpoint=True) # include 7
# Choice: sample from an array
rng.choice([10, 20, 30, 40], size=5)
rng.choice([10, 20, 30, 40], size=5, replace=True) # default
rng.choice(range(100), size=10, replace=False) # without replacement
# Why default_rng? Faster, better statistical properties, no global state.
# Legacy np.random.rand/randn/seed still works but is discouraged.Распространённые распределения
NumPy предоставляет десятки распределений через API Generator. Параметры следуют статистическим соглашениям (loc=среднее, scale=стандартное отклонение для нормального; lam=lambda для Пуассона). multivariate_normal требует ковариационную матрицу и возвращает выборки с заданной структурой корреляций. shuffle меняет массив на месте, а permutation возвращает новый массив.
import numpy as np
rng = np.random.default_rng(42)
# Continuous distributions
rng.uniform(0, 10, size=5) # uniform in [low, high)
rng.normal(loc=100, scale=15, size=5) # normal(mu, sigma)
rng.standard_normal(size=5) # standard normal
rng.exponential(scale=2.0, size=5) # exponential
rng.gamma(shape=2.0, scale=1.5, size=5)
rng.beta(a=2, b=5, size=5)
rng.lognormal(mean=0.0, sigma=1.0, size=5)
rng.chisquare(df=3, size=5)
rng.standard_t(df=10, size=5)
# Discrete distributions
rng.binomial(n=10, p=0.5, size=5)
rng.poisson(lam=3.0, size=5)
rng.geometric(p=0.1, size=5)
rng.negative_binomial(n=5, p=0.5, size=5)
# Multi-variate normal
mean = [0, 0]
cov = [[1, 0.5], [0.5, 1]]
rng.multivariate_normal(mean, cov, size=1000) # shape (1000, 2)
# Shuffle & permutation (in-place / copy)
arr = np.arange(10)
rng.shuffle(arr) # in-place shuffle
perm = rng.permutation(10) # returns a new arrayВоспроизводимость и seed
Для воспроизводимых экспериментов фиксируйте и seed, и версию NumPy: поток случайных чисел может меняться между релизами. Для параллельных вычислений используйте spawn() для создания независимых дочерних потоков; никогда не добавляйте просто индекс воркера к seed (коллизии вероятнее, чем кажется). SeedSequence корректно разделяет энтропию.
import numpy as np
# Same seed -> same sequence of random numbers
r1 = np.random.default_rng(42)
r2 = np.random.default_rng(42)
print(r1.random(3)) # [0.7739 0.4389 0.8586]
print(r2.random(3)) # same exact values
# Different seeds -> independent sequences
r3 = np.random.default_rng(123)
print(r3.random(3)) # different values
# Seed from entropy (non-reproducible) - default if seed omitted
r4 = np.random.default_rng() # seeded from OS entropy
# Spawn independent child generators (for parallelism)
parent = np.default_rng(42)
children = parent.spawn(4) # 4 independent Generators
# Each child produces an independent, reproducible stream
# SeedSequence for advanced control
ss = np.random.SeedSequence(42)
child_seeds = ss.spawn(4)
streams = [np.random.default_rng(s) for s in child_seeds]
# Reproducibility across versions: pin numpy version too!Перемешивание, перестановка, выборка
Используйте rng.permutation(indices), а затем fancy-индексацию данных: это канонический паттерн перемешивания набора перед обучением. choice с replace=False — выборка без возвращения; с p= можно задать свои вероятности. Для бутстрэпа используйте rng.integers, чтобы выбирать с возвращением (одно значение может встретиться несколько раз).
import numpy as np
rng = np.random.default_rng(42)
# Shuffle (in-place)
a = np.arange(10)
rng.shuffle(a) # a is now shuffled
# Permutation (returns a new array, original untouched)
b = np.arange(10)
perm = rng.permutation(b)
# b is unchanged, perm is the shuffled version
# Permutation of indices (common pattern for shuffling a dataset)
idx = rng.permutation(100)
X_shuffled = X[idx]
y_shuffled = y[idx]
# Random choice
rng.choice(100, size=10, replace=False) # 10 unique indices
rng.choice([1, 2, 3], size=10, p=[0.1, 0.3, 0.6]) # weighted
# Sample rows of a 2-D array
data = np.arange(20).reshape(10, 2)
row_idx = rng.choice(10, size=3, replace=False)
sample = data[row_idx] # 3 random rows
# Bootstrap sampling (with replacement)
boot_idx = rng.integers(0, len(data), size=len(data))
boot_sample = data[boot_idx]Установка random state (устаревший API)
Устаревший API np.random.seed/rand/randn использует глобальное изменяемое состояние — удобно в REPL, но хрупко в библиотеках и параллельном коде. Если всё же нужен старый API, создавайте явный объект RandomState, а не меняйте глобальное состояние. В новом коде всегда используйте default_rng. Соглашения об аргументах немного различаются (randint по умолчанию не включает high; integers включает high только при endpoint=True).