Словарь

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

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

<

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

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

>

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

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

расширенное индексирование

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

по оси

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

большой порядок байтов

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

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

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

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

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

• no: типы данных вообще не должны преобразовываться. Любой несовпадении типов данных между массивами вызовет TypeError.
• equiv: разрешены только изменения порядка байтов.
• safe: разрешены только преобразования, которые могут сохранить значения. Повышение типа (например, от int до float) разрешено, но понижение типа не разрешено.
• same_kind: опция приведения «same_kind» разрешает безопасные преобразования и преобразования в пределах одного типа, например, float64 в float32.
• unsafe: любые преобразования данных могут быть выполнены.

столбцевый порядок

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

смежный

Массив смежный, если:

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

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

• Массивы, смежные в порядке Fortran, относятся к данным, которые хранятся по столбцам, т. е. индексация данных, хранящихся в памяти, начинается с наименьшего измерения;
• Смежные массивы в порядке C, или просто смежные массивы, относятся к данным, которые хранятся по строкам, т. е. индексация данных, хранящихся в памяти, начинается с наибольшего измерения.

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

Например, двумерный массив 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. Чтобы проверить смежность в порядке Fortran, используйте атрибут .flags.f_contiguous.

копия

См. вид.

размерность

См. ось.

тип данных

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

индексирование по списку

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

поле

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

Порядок Fortran

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

распакованный

См. ravel.

однородный

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

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

размер элемента

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

маленький конец

См. 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 класс матрицы больше не должен использоваться; используйте обычные ndarray.

ndarray

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

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

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

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, см. Массив NumPy: структура для эффективного численного вычисления.

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

Массив, чьё 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 есть встроенные ufunc, но пользователи также могут написать свои.

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

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