numpy — numpy-совместимые операции с массивами

Подмодуль numpy модуля ulab предоставляет numpy-совместимый API, построенный вокруг n-мерного типа массива ndarray. Он реализует тщательно отобранное подмножество CPython numpy: создание массивов, поэлементную математику, свёртки и статистику, линейную алгебру, БПФ, генерацию случайных чисел, аппроксимацию полиномами и базовый ввод-вывод.

Подмодуль по соглашению импортируется как np:

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Каждый аргумент dtype является одной из целочисленных констант, доступных на уровне модуля: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (по умолчанию) и (если поддержка комплексных чисел включена при компиляции) numpy.complex. Тип результата ndarray ссылается на numpy.ndarray.

Подмодули

• numpy.fft — Процедуры быстрого преобразования Фурье
• numpy.linalg — Процедуры линейной алгебры
• numpy.random — Генерация случайных чисел

класс ndarray — n-мерный массив

ndarray — это n-мерный контейнер с учётом dtype, лежащий в основе numpy / ulab. Данные хранятся в непрерывном блоке, интерпретация которого описывается небольшим заголовком (dtype, shape, strides, ndim, itemsize). Многие операции – reshape, transpose, срезы – только изменяют этот заголовок и поэтому очень дёшевы; методы, выделяющие новую память (copy, flatten, большинство арифметических операций), возвращают новый плотный массив.

Тот же тип доступен как ulab.ndarray, numpy.ndarray и (в пределах этой страницы) просто ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)

Создать новый ndarray.

Параметры:

• values – Исходные данные. Либо другой ndarray (который копируется глубоко, с преобразованием типа, если dtype отличается), либо любой итерируемый объект MicroPython. Вложенные итерируемые объекты порождают многомерные массивы; все внутренние итерируемые объекты должны иметь одинаковую длину, иначе возбуждается ValueError.

• dtype – Тип элементов нового массива. Один из целочисленных кодов типов, доступных в numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float, а также – если поддерживается – numpy.complex), либо экземпляр dtype. По умолчанию numpy.float.

Фабричная функция numpy.array является общепринятым способом создания ndarray; она перенаправляет вызов этому конструктору.

byteswap(*, inplace: bool = False) → ndarray

Поменять порядок байтов каждого элемента. Для массивов uint16, int16, float и complex это меняет порядок байтов внутри каждого элемента, что полезно при чтении данных от периферийных устройств, порядок байтов которых не совпадает с порядком байтов микроконтроллера. Для однобайтовых dtype (bool, uint8, int8) это пустая операция, возвращающая представление или копию.

Если inplace равно False (по умолчанию), возвращается новый ndarray, а исходный остаётся нетронутым. Если inplace равно True, байты self меняются местами на месте и возвращается представление self.

copy() → ndarray

Вернуть новую плотную глубокую копию массива. Копия владеет собственными данными; изменения в ней не затрагивают оригинал.

flatten(*, order: str = 'C') → ndarray

Вернуть новую одномерную копию массива.

Параметры:

order – 'C' (по умолчанию) обходит данные в порядке C (последняя ось меняется быстрее всего); 'F' обходит их в порядке Fortran (первая ось меняется быстрее всего).

reshape(shape: int | tuple[int, ...]) → ndarray

Вернуть представление массива с новой формой. Общее число элементов должно остаться неизменным, иначе возбуждается ValueError. Доступно только при ULAB_MAX_DIMS > 1. Эквивалентно присваиванию shape.

sort(*, axis: int | None = -1) → None

Отсортировать массив на месте.

Параметры:

axis – Ось, вдоль которой выполняется сортировка. -1 (по умолчанию) сортирует вдоль последней оси; None сначала разворачивает массив в плоский, а затем сортирует.

tobytes() → bytearray

Вернуть bytearray, который ссылается на буфер данных, лежащий в основе массива. Запись через возвращённый bytearray изменяет массив на месте. Возбуждает ValueError, если массив не является плотным (например, срезовое представление).

tolist() → list

Вернуть содержимое массива в виде (возможно, вложенного) Python-списка list. Глубина вложенности равна ndim.

transpose() → ndarray

Вернуть транспонирование массива (оси в обратном порядке). Для одномерных массивов возвращается self. Доступно только при ULAB_MAX_DIMS > 1. Атрибут T является сокращением для этого метода.

dtype: dtype | int

Тип данных элементов массива. Возвращает экземпляр dtype, если прошивка собрана с включённым ULAB_HAS_DTYPE_OBJECT, иначе – лежащий в основе односимвольный код типа в виде целого числа.

flat: flatiter

Плоский итератор, выдающий каждый элемент массива в порядке C. В отличие от flatten(), итерация по flat не выделяет новый массив.

itemsize: int

Размер одного элемента массива в байтах, выводимый из dtype.

ndim: int

Число измерений массива (длина shape).

shape: tuple[int, ...]

Длины массива вдоль каждой оси. Присваивание кортежа атрибуту shape изменяет форму массива на месте (эквивалентно reshape()).

size: int

Общее число элементов в массиве (произведение shape).

strides: tuple[int, ...]

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

T: ndarray

Транспонирование массива; эквивалентно transpose().

real: ndarray

Действительная часть комплексного массива, возвращаемая как float ndarray. Для действительных массивов это копия self с тем же dtype. Доступно только если прошивка собрана с поддержкой комплексных чисел.

imag: ndarray

Мнимая часть комплексного массива, возвращаемая как float ndarray. Для действительных массивов это массив нулей с тем же dtype, что и self. Доступно только если прошивка собрана с поддержкой комплексных чисел.

Поддерживаемые операторы

Экземпляры ndarray поддерживают следующие операторы. Бинарные операторы транслируют свои операнды по стандартным правилам broadcasting numpy и следуют правилам повышения типов numpy (например, uint8 + int8 => int16, uint16 + int16 => float); операции с участием комплексного операнда дают комплексный результат.

Арифметические (бинарные): +, -, *, /, //, %, **. Отражённые (правосторонние) операнды и варианты с присваиванием на месте +=, -=, *=, /=, %=, **= также поддерживаются. Принимаются обе формы: ndarray-с-ndarray и ndarray-со-скаляром. Целочисленное деление (//) и оператор взятия по модулю (%) не реализованы для массивов complex.

Сравнение: ==, !=, <, <=, >, >=. Каждый возвращает булев ndarray транслированной формы.

Побитовые (только целочисленные массивы): &, |, ^. Применение их к массиву float или complex возбуждает TypeError.

Унарные: + (возвращает копию), - (отрицание; для беззнаковых dtype значения переполняются по модулю \(2^N\)), abs() (поэлементное абсолютное значение; для беззнаковых dtype возвращает копию без вычислений), ~ (побитовая инверсия, только целочисленные dtype), len() (возвращает длину первой оси).

Индексация и срезы: a[i], a[i, j, ...], a[start:stop:step], индексация булевой маской (a[mask]) и индексация целочисленным массивом (fancy) поддерживаются как при чтении, так и при записи.

Итерация: Итерация по ndarray выдаёт подмассивы вдоль первой оси (по одному элементу за раз для одномерных массивов). Используйте flat для итерации по каждому скалярному элементу независимо от размерности.

Оператор матричного умножения @ не реализован; используйте вместо него numpy.dot (np.dot(a, b)).

Операторы сдвига (<<, >>) не реализованы на уровне операторов. Используйте numpy.left_shift и numpy.right_shift для поэлементных целочисленных сдвигов.

Создание массивов

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray

Создать новый ndarray из вложенного итерируемого объекта чисел. Эквивалентный альтернативный конструктор для numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray

Вернуть равномерно распределённые значения на полуоткрытом интервале [start, stop). Если задан только один позиционный аргумент, он трактуется как stop при start = 0. Если dtype опущен, он выводится из входных данных (целочисленный, если все из start, stop, step являются целыми и в пределах диапазона).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray

Если a уже является ndarray, чей dtype совпадает с dtype (или dtype равен None), вернуть a без изменений; иначе создать новый массив (с запрошенным преобразованием dtype, если оно задано). Итерируемые объекты преобразуются как в numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray

Объединить последовательность ndarray вдоль существующей оси axis. Все входные массивы должны иметь одинаковые dtype, ndim и форму по каждой оси, кроме axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray

Для двумерного a вернуть одномерный массив, содержащий k-ю диагональ. Для одномерного a вернуть двумерный квадратный массив с a, размещённым на k-й диагонали. k может быть положительным (выше главной диагонали) или отрицательным (ниже).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Псевдоним для zeros; возвращает массив заданной формы shape и dtype, заполненный нулями. (ulab не оставляет буфер неинициализированным.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray

Вернуть двумерный массив N x M (квадратный N x N, если M равно None) с единицами на k-й диагонали и нулями в остальных местах.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray

Интерпретировать объект, поддерживающий протокол буфера, как одномерный ndarray типа dtype. count – число читаемых элементов (-1 читает все доступные элементы); offset пропускает указанное число байтов в начале буфера.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray

Вернуть новый массив формы shape и типа dtype с каждым элементом, установленным в fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]

Вернуть num равномерно распределённых отсчётов на закрытом интервале [start, stop] (или полуоткрытом, если endpoint равно False). Когда retstep равно True, вернуть кортеж (samples, step). Комплексные start/stop дают комплексный массив (если поддержка комплексных чисел включена).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray

Вернуть num отсчётов, равномерно распределённых по логарифмической шкале: результат начинается с base ** start и заканчивается base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]

Вернуть кортеж координатных матриц из последовательности одномерных координатных массивов. При indexing 'xy' (по умолчанию) первые два входа трактуются как декартовы координаты, и их выходные оси меняются местами; при 'ij' используется матричная индексация. Реализация соответствует эквиваленту NumPy с copy=True и sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Вернуть новый массив формы shape и типа dtype, заполненный единицами.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Вернуть новый массив формы shape и типа dtype, заполненный нулями.

Инспекция / печать

numpy.get_printoptions() → dict

Вернуть текущие параметры печати массивов в виде словаря с ключами threshold и edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None

Установить параметры печати массивов. threshold – максимальное число элементов массива, печатаемых полностью; edgeitems – число элементов, показываемых на каждом конце оси, когда массив выводится сокращённо.

numpy.ndinfo(array: ndarray) → None

Напечатать диагностическую информацию (форму, шаги, dtype, itemsize, …) о массиве array.

numpy.size(a: ndarray, *, axis: int | None = None) → int

Вернуть число элементов a вдоль оси axis; если axis равно None, вернуть общее число элементов (произведение ndarray.shape).

Сравнение

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float

Ограничить значения a так, чтобы a_min <= result <= a_max. Эквивалентно maximum(a_min, minimum(a, a_max)); broadcasting следует тем же правилам, что и minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

Поэлементное x1 == x2; возвращает булев ndarray (или скаляр bool, если оба входа являются скалярами). Предоставляется для переносимости – оператор == над массивами даёт тот же результат.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

Поэлементное x1 != x2; булев аналог equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool

Вернуть булев массив (или скаляр), который равен True там, где вход конечен. Целочисленные входы всегда конечны.

numpy.isinf(x: ndarray | int | float) → ndarray | bool

Вернуть булев массив (или скаляр), который равен True там, где вход бесконечен. Целочисленные входы никогда не бывают бесконечными.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

Поэлементный максимум двух массивов / скаляров. Аргументы транслируются вместе; если dtype различаются, выход повышается до более широкого типа.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

Поэлементный минимум двух массивов / скаляров; аналог maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]

Вернуть кортеж ndarray, по одному на каждое измерение a, содержащий индексы ненулевых элементов a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray

Вернуть ndarray, элементы которого берутся из x там, где condition истинно, и из y в остальных случаях. Три входа транслируются вместе; dtype выхода является повышением типов x и y.

Числовые свёртки

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

Проверить, все ли элементы вдоль оси axis дают True. При axis=None (по умолчанию) проверяется развёрнутый в плоский массив, и возвращается единственный bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

Проверить, даёт ли хоть один элемент вдоль оси axis значение True. При axis=None проверяется развёрнутый в плоский массив.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

Вернуть индекс максимального элемента вдоль оси axis. При axis=None массив разворачивается в плоский и возвращается единственное целое число.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

Вернуть индекс минимального элемента вдоль оси axis. При axis=None массив разворачивается в плоский и возвращается единственное целое число.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray

Вернуть ndarray беззнаковых целочисленных индексов, чьи элементы сортируют a по возрастанию вдоль оси axis. dtype выхода равен uint16, поэтому ни одна ось не может превышать 65535 элементов. axis=None не поддерживается.

numpy.cross(a: ndarray, b: ndarray) → ndarray

Вернуть векторное произведение двух одномерных массивов длины 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray

Вернуть n-ю дискретную прямую разность a вдоль оси axis. n должно быть в диапазоне 0..9 (шаблон дифференцирования хранится в int8); длина оси axis уменьшается на n. Ключевые слова numpy prepend и append не реализованы.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray

Вернуть новый массив с порядком элементов, обратным вдоль оси axis; при axis=None массив обращается вдоль каждой оси.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Вернуть максимальный элемент вдоль оси axis. При axis=None (по умолчанию) развёрнутый в плоский массив сводится к скаляру. Ключевое слово numpy out не реализовано.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Вернуть минимальный элемент вдоль оси axis; аналог max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float

Вернуть среднее арифметическое вдоль оси axis. При axis=None (по умолчанию) среднее развёрнутого в плоский массива возвращается как float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float

Вернуть медиану вдоль оси axis. При axis=None массив сначала разворачивается в плоский. dtype выхода всегда float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray

Вернуть a с элементами, прокрученными (циклически сдвинутыми) на shift позиций. При axis=None (по умолчанию) массив сначала разворачивается в плоский. Отрицательные сдвиги прокручивают в противоположном направлении.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray

Вернуть отсортированную копию a вдоль оси axis с использованием пирамидальной сортировки. При axis=None массив сначала разворачивается в плоский. Ключевые слова numpy kind и order не реализованы.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float

Вернуть стандартное отклонение вдоль оси axis. ddof – дельта числа степеней свободы; используемый делитель равен N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Вернуть сумму вдоль оси axis. При axis=None сумма развёрнутого в плоский массива возвращается как скаляр.

Статистика

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray

Подсчитать число вхождений каждого значения в одномерном неотрицательном целочисленном массиве x. dtype x должен быть uint8 или uint16. Если задан weights, каждый элемент x вносит соответствующий вес, а не 1, и выход имеет dtype float; иначе выход имеет dtype uint16. Если задан minlength, выходной массив содержит по крайней мере столько элементов (лишние элементы равны нулю).

numpy.trace(m: ndarray) → int | float

Вернуть сумму диагональных элементов квадратной матрицы m. Тип возвращаемого значения следует dtype m (целочисленные массивы дают целое число, массивы float – float).

Преобразование

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray

Вернуть срезы a, выбранные вдоль оси axis по булеву условию condition. При axis=None используется развёрнутый в плоский массив.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray

Вернуть копию a с удалёнными вдоль оси axis элементами по индексам indices. При axis=None массив сначала разворачивается в плоский. Отрицательные индексы отсчитываются от конца оси axis; indices внутренне сортируется перед удалением.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float

Вернуть скалярное произведение двух массивов. Для двух одномерных массивов это внутреннее произведение (скаляр float). Для двумерных массивов это матричное умножение; внутренние размерности должны совпадать. Результат всегда имеет dtype float.

Аппроксимация

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray

Одномерная линейная интерполяция. xp должен быть монотонно возрастающим одномерным массивом независимых значений; fp содержит соответствующие зависимые значения; x – точки, в которых вычисляется интерполянт. left и right переопределяют значение, возвращаемое для x < xp[0] и x > xp[-1] соответственно (по умолчанию: fp[0] и fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float

Проинтегрировать y по составной формуле трапеций. Если задан x, он предоставляет позиции отсчётов, соответствующие y; иначе используется шаг dx. y (и x) должны быть одномерными.

Выбор

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray

Взять элементы из a по заданным индексам indices вдоль оси axis. При axis=None используется развёрнутый в плоский массив. mode выбирает поведение при выходе за границы: "raise" (по умолчанию – возбудить ValueError), "wrap" (по модулю длины оси) или "clip" (ограничить допустимым диапазоном; отрицательные индексы не допускаются). Если задан out, результат записывается в него.

Побитовые операции

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray

Поэлементное побитовое И двух целочисленных массивов; broadcasting поддерживается. Нецелочисленный dtype возбуждает исключение.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray

Поэлементное побитовое ИЛИ двух целочисленных массивов.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray

Поэлементное побитовое исключающее ИЛИ двух целочисленных массивов.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray

Поэлементный побитовый сдвиг x1 влево на x2 битов; оба массива должны иметь целочисленный dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray

Поэлементный побитовый сдвиг x1 вправо на x2 битов; оба массива должны иметь целочисленный dtype.

Фильтрация

numpy.convolve(a: ndarray, v: ndarray) → ndarray

Вернуть дискретную линейную свёртку двух одномерных массивов. Поддерживается только режим "full"; ключевое слово numpy mode не принимается (другие режимы можно получить, взяв срез полного результата). Длина выхода равна len(a) + len(v) - 1.

Полиномы

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray

Аппроксимировать данные точки (x, y) полиномом степени deg методом наименьших квадратов и вернуть коэффициенты полинома (старшая степень первой). Если x опущен, используется range(len(y)). Возбуждает ValueError, если длины x и y различаются.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float

Вычислить полином с коэффициентами p (старшая степень первой) в точке x. Если x является скаляром, возвращается float, иначе ndarray.

I/O

numpy.load(file: str) → ndarray

Прочитать массив, ранее записанный с помощью save, из файла file (платформонезависимый формат .npy numpy). Порядок байтов преобразуется на лету, если порядок байтов файла отличается от порядка байтов хоста.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray

Прочитать числовые данные из текстового файла file и вернуть их как ndarray. delimiter по умолчанию – пробельные символы; comments – маркер строкового комментария; max_rows ограничивает число читаемых строк данных (-1 для всех); usecols выбирает столбцы по индексу; skiprows пропускает указанное число начальных строк. Если dtype не float, значения преобразуются округлением.

numpy.save(file: str, a: ndarray) → None

Сохранить a в файл file в платформонезависимом формате .npy numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None

Записать a в файл file в виде текста. delimiter разделяет значения внутри строки; header и footer, если заданы, записываются до/после данных, каждый с префиксом comments. Значения записываются как числа с плавающей точкой.

Помощники для комплексных чисел

Эти функции доступны только если ulab был скомпилирован с поддержкой комплексных чисел (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray

Вернуть действительную часть val. Для входа с действительным dtype возвращается копия с сохранением dtype; для комплексного входа возвращается ndarray типа float.

numpy.imag(val: ndarray) → ndarray

Вернуть мнимую часть val. Для входа с действительным dtype возвращается массив нулей с тем же dtype; для комплексного входа возвращается ndarray типа float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float

Вернуть комплексно-сопряжённое значение val. Действительнозначные входы возвращаются без изменений.

numpy.sort_complex(a: ndarray) → ndarray

Отсортировать одномерный массив a сначала по действительной части, затем по мнимой. Результат всегда имеет комплексный dtype, даже если a был действительнозначным.

Универсальные функции

Поэлементные математические функции. Каждая принимает скаляр или ndarray и возвращает результат соответствующей формы (скаляр float для скалярного входа, ndarray для входа-массива). При вызове с ndarray результатом является новый ndarray с плавающей точкой; можно передать необязательное ключевое слово out для записи результата в заранее выделенный ndarray типа float того же размера.

numpy.acos(x: ndarray | float, /) → ndarray | float

Вычислить обратный косинус (арккосинус) каждого элемента x; результат в радианах.

numpy.acosh(x: ndarray | float, /) → ndarray | float

Вычислить обратный гиперболический косинус каждого элемента x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float

Вычислить двухаргументный обратный тангенс atan2(y, x) поэлементно; поддерживает broadcasting между двумя входами.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray

Округлить элементы ndarray x до заданного числа знаков decimals; первый аргумент должен быть ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float

Вычислить обратный синус (арксинус) каждого элемента x; результат в радианах.

numpy.asinh(x: ndarray | float, /) → ndarray | float

Вычислить обратный гиперболический синус каждого элемента x.

numpy.atan(x: ndarray | float, /) → ndarray | float

Вычислить обратный тангенс (арктангенс) каждого элемента x; результат в радианах.

numpy.atanh(x: ndarray | float, /) → ndarray | float

Вычислить обратный гиперболический тангенс каждого элемента x.

numpy.ceil(x: ndarray | float, /) → ndarray | float

Вычислить потолок (наименьшее целое число, не меньшее значения) каждого элемента x.

numpy.cos(x: ndarray | float, /) → ndarray | float

Вычислить косинус каждого элемента x (в радианах).

numpy.cosh(x: ndarray | float, /) → ndarray | float

Вычислить гиперболический косинус каждого элемента x.

numpy.degrees(x: ndarray | float, /) → ndarray | float

Преобразовать каждый элемент x из радианов в градусы.

numpy.exp(x: ndarray | float, /) → ndarray | float

Вычислить экспоненту e**x каждого элемента x; может вернуть комплексный ndarray при комплексном входе (если поддержка комплексных чисел включена).

numpy.expm1(x: ndarray | float, /) → ndarray | float

Вычислить exp(x) - 1 каждого элемента x с повышенной точностью вблизи нуля.

numpy.floor(x: ndarray | float, /) → ndarray | float

Вычислить пол (наибольшее целое число, не большее значения) каждого элемента x.

numpy.log(x: ndarray | float, /) → ndarray | float

Вычислить натуральный логарифм каждого элемента x.

numpy.log10(x: ndarray | float, /) → ndarray | float

Вычислить десятичный логарифм каждого элемента x.

numpy.log2(x: ndarray | float, /) → ndarray | float

Вычислить двоичный логарифм каждого элемента x.

numpy.radians(x: ndarray | float, /) → ndarray | float

Преобразовать каждый элемент x из градусов в радианы.

numpy.sin(x: ndarray | float, /) → ndarray | float

Вычислить синус каждого элемента x (в радианах).

numpy.sinc(x: ndarray | float, /) → ndarray | float

Вычислить нормированную функцию sinc sin(pi*x) / (pi*x) каждого элемента x.

numpy.sinh(x: ndarray | float, /) → ndarray | float

Вычислить гиперболический синус каждого элемента x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float

Вычислить квадратный корень каждого элемента x; передайте dtype=numpy.complex для получения комплексных результатов для отрицательных действительных входов (если поддержка комплексных чисел включена).

numpy.tan(x: ndarray | float, /) → ndarray | float

Вычислить тангенс каждого элемента x (в радианах).

numpy.tanh(x: ndarray | float, /) → ndarray | float

Вычислить гиперболический тангенс каждого элемента x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable

Вернуть вызываемый объект, применяющий Python-функцию f поэлементно к скаляру, итерируемому объекту или ndarray; otypes выбирает выходной dtype (по умолчанию float).

Константы

numpy.e: float

Число Эйлера \(e \approx 2.71828\).

numpy.pi: float

\(\pi \approx 3.14159\).

numpy.inf: float

Положительная бесконечность с плавающей точкой IEEE-754.

numpy.nan: float

«Не число» (NaN) с плавающей точкой IEEE-754.

numpy.bool: int

Код dtype для булевых массивов (хранятся как uint8).

numpy.uint8: int

Код dtype для массивов беззнаковых 8-битных целых чисел.

numpy.int8: int

Код dtype для массивов знаковых 8-битных целых чисел.

numpy.uint16: int

Код dtype для массивов беззнаковых 16-битных целых чисел.

numpy.int16: int

Код dtype для массивов знаковых 16-битных целых чисел.

numpy.float: int

Код dtype для массивов 32-битных чисел с плавающей точкой.