Глоссарий#

(n,)#

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

-1#

  • В записи измерения, указывает NumPy выбрать длину, которая сохранит общее количество элементов массива неизменным.

    >>> np.arange(12).reshape(4, -1).shape
(4, 3)

  • В индекселюбое отрицательное значение обозначает индексация справа.

…#

An Ellipsis.

  • При индексации массива, сокращение, означающее, что отсутствующие оси, если они существуют, являются полными срезами.

    >>> a = np.arange(24).reshape(2,3,4)

    >>> a[...].shape
(2, 3, 4)

    >>> a[...,0].shape
(2, 3)

    >>> a[0,...].shape
(3, 4)

    >>> a[0,...,0].shape
(3,)

    Может использоваться не более одного раза; a[...,0,...] вызывает IndexError.

  • В выводах, NumPy заменяет ... для средних элементов больших массивов. Чтобы увидеть весь массив, используйте numpy.printoptions

:#

Python срез оператор. В ndarray срезы могут применяться к каждой оси:

>>> a = np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

>>> a[1:,-2:,:-1]
array([[[16, 17, 18],
        [20, 21, 22]]])

Завершающие срезы могут быть опущены:

>>> a[1] == a[1,:,:]
array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

В отличие от Python, где срез создает копию, в NumPy срез создает представление.

Подробности см. в Комбинирование расширенной и базовой индексации.

<#

В объявлении dtype указывает, что данные являются little-endian (скобка большая справа).

>>> dt = np.dtype(')  # little-endian single-precision float
>#

В объявлении dtype указывает, что данные являются big-endian (скобка большая слева).

>>> dt = np.dtype('>H')  # big-endian unsigned short
расширенная индексация#

Вместо использования скаляр или срез в качестве индекса, ось может быть проиндексирована массивом, обеспечивая детальный выбор. Это известно как расширенная индексация или «причудливая индексация».

вдоль оси#

Операция вдоль оси n массива a ведёт себя так, как если бы его аргумент был массивом срезов a где каждый срез имеет последовательный индекс оси n.

Например, если a является 3 x N массив, операция вдоль оси 0 ведёт себя так, как если бы её аргумент был массивом, содержащим срезы каждой строки:

>>> np.array((a[0,:], a[1,:], a[2,:]))

Для конкретики мы можем выбрать операцией функцию обращения массива numpy.flip, который принимает axis аргумент. Мы создаем массив 3 x 4 a:

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

Обращение вдоль оси 0 (оси строк) дает

>>> np.flip(a,axis=0)
array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 0,  1,  2,  3]])

Вспоминая определение вдоль оси, flip вдоль оси 0 обрабатывает свой аргумент, как если бы он был

>>> np.array((a[0,:], a[1,:], a[2,:]))
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

и результат np.flip(a,axis=0) заключается в обращении срезов:

>>> np.array((a[2,:],a[1,:],a[0,:]))
array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 0,  1,  2,  3]])
массив#

Используется как синоним в документации NumPy для ndarray.

array_like#

Любой скаляр или последовательность который может быть интерпретирован как ndarray. В дополнение к ndarrays и скалярам эта категория включает списки (возможно вложенные и с разными типами элементов) и кортежи. Любой аргумент, принимаемый numpy.array является array_like.

>>> a = np.array([[1, 2.0], [0, 0], (1+1j, 3.)])

>>> a
array([[1.+0.j, 2.+0.j],
       [0.+0.j, 0.+0.j],
       [1.+1.j, 3.+0.j]])
скаляр массива#

An скаляр массива является экземпляром типов/классов float32, float64, и т.д. Для единообразия обработки операндов NumPy рассматривает скаляр как массив нулевой размерности. В отличие от этого, 0-мерный массив — это ndarray экземпляр, содержащий ровно одно значение.

ось#

Другое название для размерности массива. Оси нумеруются слева направо; ось 0 - первый элемент в кортеже формы.

В двумерном векторе элементы оси 0 — это строки, а элементы оси 1 — столбцы.

В более высоких измерениях картина меняется. NumPy выводит векторы более высоких измерений как репликации строительных блоков строка-столбец, как в этом трехмерном векторе:

>>> a = np.arange(12).reshape(2,2,3)
>>> a
array([[[ 0,  1,  2],
        [ 3,  4,  5]],
       [[ 6,  7,  8],
        [ 9, 10, 11]]])

a изображается как массив из двух элементов, чьи элементы являются векторами 2x3. С этой точки зрения строки и столбцы являются последними двумя осями соответственно в любой форме.

Это правило помогает предсказать, как будет напечатан вектор, и наоборот, как найти индекс любого из напечатанных элементов. Например, в примере последние два значения индекса 8 должны быть 0 и 2. Поскольку 8 появляется во втором из двух 2x3, первый индекс должен быть 1:

>>> a[1,0,2]
8

Удобный способ подсчета размерностей в напечатанном векторе — подсчитать [ символов после открывающей скобки. Это полезно для различения, например, формы (1,2,3) от формы (2,3):

>>> a = np.arange(6).reshape(2,3)
>>> a.ndim
2
>>> a
array([[0, 1, 2],
       [3, 4, 5]])

>>> a = np.arange(6).reshape(1,2,3)
>>> a.ndim
3
>>> a
array([[[0, 1, 2],
        [3, 4, 5]]])
.base#

Если массив не владеет своей памятью, то его основание атрибут возвращает объект, на память которого ссылается массив. Этот объект может ссылаться на память из другого объекта, поэтому владеющий объект может быть a.base.base.base.... Некоторые авторы ошибочно утверждают, что тестирование base определяет, являются ли массивы представлениеs. Для правильного способа см. numpy.shares_memory.

big-endian#

См. Порядок байтов.

BLAS#

Basic Linear Algebra Subprograms

broadcast#

вещание это способность NumPy обрабатывать ndarrays разных размеров, как если бы все они были одного размера.

Это позволяет элегантно реализовать поведение «сделай то, что я имею в виду», где, например, добавление скаляра к вектору добавляет скалярное значение к каждому элементу.

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> a + [3, 3, 3]
array([3, 4, 5])

>>> a + 3
array([3, 4, 5])

Обычно векторные операнды должны быть одного размера, потому что NumPy работает поэлементно — например, c = a * b является

 c[0,0,0] = a[0,0,0] * b[0,0,0]
 c[0,0,1] = a[0,0,1] * b[0,0,1]
...

Но в некоторых полезных случаях NumPy может дублировать данные вдоль "отсутствующих" осей или "слишком коротких" измерений, чтобы формы совпадали. Дублирование не требует памяти или времени. Подробности см. в Широковещание.

Порядок C#

То же, что и row-major.

приведение типов#

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

  • no: Типы данных не должны преобразовываться вообще. Любое несоответствие типов данных между массивами вызовет TypeError.

  • equiv: Разрешены только изменения порядка байтов.

  • safe: Разрешены только преобразования, которые могут сохранить значения. Повышение типа (например, из int в float) разрешено, но понижение типа — нет.

  • same_kind: Опция приведения 'same_kind' позволяет безопасные приведения и приведения внутри одного типа, например float64 к float32.

  • unsafe: любые преобразования данных могут быть выполнены.

column-major#

См. Порядок хранения по строкам и по столбцам.

непрерывный#

Массив является непрерывным, если:

  • он занимает непрерывный блок памяти, и

  • элементы массива с более высокими индексами занимают более высокие адреса (т.е. нет шаг отрицательно).

Существует два типа правильно непрерывных массивов NumPy:

  • Массивы с хранением по столбцам (Fortran-contiguous) относятся к данным, которые хранятся по столбцам, т.е. индексация данных, как они хранятся в памяти, начинается с самого низкого измерения;

  • C-непрерывные, или просто непрерывные массивы, относятся к данным, которые хранятся построчно, т.е. индексация данных, как они хранятся в памяти, начинается с самого высокого измерения.

Для одномерных массивов эти понятия совпадают.

Например, массив 2x2 A является Fortran-непрерывным, если его элементы хранятся в памяти в следующем порядке:

A[0,0] A[1,0] A[0,1] A[1,1]

и C-непрерывным, если порядок следующий:

A[0,0] A[0,1] A[1,0] A[1,1]

Чтобы проверить, является ли массив C-непрерывным, используйте .flags.c_contiguous атрибут массивов NumPy. Для проверки на фортран-непрерывность используйте .flags.f_contiguous атрибут.

copy#

См. представление.

измерение#

См. ось.

dtype#

Тип данных, описывающий (идентично типизированные) элементы в ndarray. Его можно изменить для переинтерпретации содержимого массива. Подробности см. в Объекты типов данных (dtype).

расширенная индексация#

Другое название для расширенная индексация.

field#

В структурированный тип данных, каждый подтип называется field. field имеет имя (строка), тип (любой допустимый dtype) и необязательный title. См. Объекты типа данных (dtype).

Порядок Fortran#

То же, что и column-major.

уплощённый#

См. ravel.

однородный#

Все элементы однородного массива имеют одинаковый тип. В отличие от списков Python, ndarrays являются однородными. Тип может быть сложным, как в структурированный массив, но все элементы имеют этот тип.

NumPy массивы объектов, которые содержат ссылки на объекты Python, выполняют роль гетерогенных массивов.

itemsize#

Размер элемента dtype в байтах.

little-endian#

См. Порядок байтов.

маска#

Логический массив, используемый для выбора только определенных элементов для операции:

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> mask = (x > 2)
>>> mask
array([False, False, False, True,  True])

>>> x[mask] = -1
>>> x
array([ 0,  1,  2,  -1, -1])
маскированный массив#

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

>>> a = np.ma.masked_array([np.nan, 2, np.nan], [True, False, True])
>>> a
masked_array(data=[--, 2.0, --],
             mask=[ True, False,  True],
       fill_value=1e+20)

>>> a + [1, 2, 3]
masked_array(data=[--, 4.0, --],
             mask=[ True, False,  True],
       fill_value=1e+20)

Подробности см. в Маскированные массивы.

матрица#

Двумерный массив NumPy класс матрицы больше не следует использовать; используйте обычные ndarrays.

ndarray#

Базовая структура NumPy.

массив объектов#

Массив, чей dtype является object; то есть он содержит ссылки на объекты Python. Индексация массива разыменовывает объекты Python, поэтому, в отличие от других ndarrays, объектный массив может содержать разнородные объекты.

ravel#

numpy.ravel и numpy.flatten оба сглаживают ndarray. ravel вернёт представление, если это возможно; flatten всегда возвращает копию.

Выравнивание сворачивает многомерный массив в одно измерение; детали того, как это делается (например, ли a[n+1] должны быть следующей строкой или следующим столбцом) являются параметрами.

записывающий массив#

A структурированный массив с разрешением доступа в стиле атрибута (a.field) в дополнение к a['field']. Подробности см. в numpy.recarray.

row-major#

См. Порядок хранения по строкам и по столбцам. NumPy по умолчанию создаёт массивы в порядке row-major.

скаляр#

В NumPy обычно синоним для скаляр массива.

shape#

Кортеж, показывающий длину каждого измерения ndarray. Длина самого кортежа — это количество измерений (numpy.ndim). Произведение элементов кортежа — это количество элементов в массиве. Подробности см. в numpy.ndarray.shape.

шаг#

Физическая память одномерна; шаги предоставляют механизм для отображения заданного индекса на адрес в памяти. Для N-мерного массива его strides атрибут представляет собой кортеж из N элементов; переход от индекса i для индексации i+1 по оси n означает добавление a.strides[n] байтов по адресу.

Шаги вычисляются автоматически на основе dtype и формы массива, но могут быть указаны напрямую с помощью as_strided.

Подробности см. в numpy.ndarray.strides.

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

структурированный массив#

Массив, чей dtype является структурированный тип данных.

структурированный тип данных#

Пользователи могут создавать произвольно сложные dtypes которые могут включать другие массивы и типы данных. Эти составные типы данных называются структурированные типы данных.

подмассив#

Массив, вложенный в структурированный тип данных, как b находится здесь:

>>> dt = np.dtype([('a', np.int32), ('b', np.float32, (3,))])
>>> np.zeros(3, dtype=dt)
array([(0, [0., 0., 0.]), (0, [0., 0., 0.]), (0, [0., 0., 0.])],
      dtype=[('a', '
тип данных подмассива#

Элемент структурированного типа данных, который ведет себя как ndarray.

title#

Псевдоним для имени поля в структурированном типе данных.

тип#

В NumPy обычно синоним для dtype. Для более общего значения в Python, см. здесь.

универсальная функция (ufunc)#

Быстрые поэлементные вычисления NumPy (векторизация) предоставляет выбор, какая функция применяется. Общий термин для функции - ufunc, сокращение от universal function. Подпрограммы NumPy имеют встроенные ufuncs, но пользователи также могут написать свои собственные.

векторизация#

NumPy передаёт обработку массивов в C, где циклы и вычисления гораздо быстрее, чем в Python. Чтобы использовать это, программисты, применяющие NumPy, устраняют циклы Python в пользу операций массив-массив. векторизация может относиться как к C оффлоадингу, так и к структурированию кода NumPy для его использования.

представление#

Не изменяя исходные данные, NumPy может заставить массив казаться изменяющим свой тип данных и форму.

Массив, созданный таким образом, является представление, и NumPy часто использует преимущество производительности при использовании представления вместо создания нового массива.

Потенциальным недостатком является то, что запись в представление может также изменить оригинал. Если это проблема, NumPy вместо этого должен создать физически отдельный массив — copy.

Некоторые процедуры NumPy всегда возвращают виды, некоторые всегда возвращают копии, некоторые могут возвращать то или другое, а для некоторых выбор может быть указан. Ответственность за управление видами и копиями лежит на программисте. numpy.shares_memory проверит, выполнен ли b является представлением a, но точный ответ не всегда возможен, как объясняется на странице документации.

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> y = x[::2]
>>> y
array([0, 2, 4])

>>> x[0] = 3 # changing x changes y as well, since y is a view on x
>>> y
array([3, 2, 4])