Словарь терминов

(n,)

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

-1

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

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

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

…

Эллипс (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 (срез). В nd-массивах срез можно применять к каждой оси:

>>> 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 срез создаёт вид.

Подробности см. в Объединение расширенного и базового индексирования.

<

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

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

>

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

>>> dt = np.dtype('>H')  # big-endian unsigned short

advanced indexing

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

along an axis

Операция along axis 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]])

Вспоминая определение along an axis, операция 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]])

array

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

array_like

Любой скаляр или последовательность, который можно интерпретировать как nd-массив. Помимо nd-массивов и скаляров, в эту категорию входят списки (возможно, вложенные и с разными типами элементов) и кортежи. Любой аргумент, принятый функцией 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]])

array scalar

Для единообразия в обработке операндов NumPy рассматривает скаляр как массив нулевой размерности.

axis

Другое название для размерности массива. Оси нумеруются слева направо; ось 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

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

big-endian

См. Порядок следования байтов.

BLAS

Основные подпрограммы линейной алгебры

broadcast

векторное расширение — это способность NumPy обрабатывать nd-массивы разных размеров так, как если бы все они имели одинаковый размер.

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

>>> 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 order

То же, что и строчный порядок.

column-major

См. Строчный и столбцевой порядок.

contiguous

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

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

copy

См. вид.

dimension

См. ось.

dtype

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

fancy indexing

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

field

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

Fortran order

То же, что и столбцевой порядок.

flattened

См. ravel.

homogeneous

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

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

itemsize

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

little-endian

См. Endianness.

mask

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

>>> 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])

masked array

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

>>> 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)

Подробности см. в Массивах с маской.

matrix

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

ndarray

Основная структура NumPy.

object array

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

ravel

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

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

record array

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

row-major

См. Row- and column-major order. NumPy по умолчанию создаёт массивы в порядке строк.

scalar

В NumPy, обычно синоним для массивно-скалярного значения.

shape

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

stride

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

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

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

Чтобы увидеть, как шаги лежат в основе мощности представлений NumPy, см. The NumPy array: a structure for efficient numerical computation.

structured array

Массив, у которого тип данных — структурированный тип данных.

structured data type

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

subarray

Вложенный массив в структурированном типе данных, как 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', '<i4'), ('b', '<f4', (3,))])

subarray data type

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

title

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

type

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

ufunc

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

vectorization

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

view

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

Массив, созданный таким образом, — это view, и 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])