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

(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 срезы. В ndarrays, срезы можно применять к каждой оси:

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

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

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

по оси

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

массив

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

похожий на массив

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

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

скаляр массива

Скаляр массива — это экземпляр типов/классов 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

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

большенормальный

См. Endianness.

BLAS

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

вещание

вещание — это способность 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

То же, что и строчно-главный.

столбцово-главный

См. Порядок строк и столбцов.

смежный

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

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

копия

См. вид.

размерность

См. ось.

тип данных

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

fancy индексация

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

поле

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

порядок Fortran

То же, что и столбцово-главный.

уплощенный

См. ravel.

однородный

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

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

itemsize

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

little-endian

См. Endianness.

маска

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

>>> 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.field) помимо a['field']. Для получения подробностей см. numpy.recarray.

строчно-главный

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

скаляр

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

форма

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

шаг

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

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

Для получения подробностей см. numpy.ndarray.strides.

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

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

Массив, чьё dtype — структурированный тип данных.

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

Пользователи могут создавать произвольно сложные dtypes, которые могут включать в себя другие массивы и dtypes. Эти составные 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', '<i4'), ('b', '<f4', (3,))])

тип данных подмассива

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

заголовок

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

тип

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

ufunc

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

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

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

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

Без изменения базовых данных 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])