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

Индексирование массивов относится к любому использованию квадратных скобок ([]) для индексирования значений массива. Существует множество вариантов индексирования, которые придают индексированию NumPy большую мощность, но с мощностью приходит определённая сложность и потенциальная путаница. Этот раздел является лишь обзором различных вариантов и проблем, связанных с индексированием. Помимо индексирования отдельных элементов, подробности по большинству из этих вариантов можно найти в соответствующих разделах.

Присваивание против ссылки

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

Индексирование одного элемента

Индексирование одного элемента для одномерного массива соответствует ожиданиям. Оно работает точно так же, как и для других стандартных последовательностей Python. Оно основано на нулевом индексе и принимает отрицательные индексы для индексирования с конца массива.

>>> x = np.arange(10)
>>> x[2]
2
>>> x[-2]
8

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

>>> x.shape = (2,5) # now x is 2-dimensional
>>> x[1,3]
8
>>> x[1,-1]
9

Обратите внимание, что если индексировать многомерный массив меньшим числом индексов, чем размерностей, то получается подмассив меньшей размерности. Например:

>>> x[0]
array([0, 1, 2, 3, 4])

То есть каждый указанный индекс выбирает массив, соответствующий остальным выбранным размерностям. В приведенном выше примере выбор 0 означает, что оставшаяся размерность длиной 5 не указана, и возвращается массив соответствующей размерности и размера. Следует отметить, что возвращаемый массив не является копией исходного, а указывает на те же значения в памяти, что и исходный массив. В данном случае возвращается одномерный массив в первой позиции (0). Таким образом, использование одиночного индекса для возвращаемого массива приводит к возврату одного элемента. То есть:

>>> x[0][2]
2

Поэтому обратите внимание на x[0,2] = x[0][2], хотя во втором случае это менее эффективно, так как после первого индекса создаётся новый временный массив, который затем индексируется значением 2.

Примечание для тех, кто привык к порядку памяти IDL или Fortran в отношении индексирования. NumPy использует индексирование в порядке C. Это означает, что последний индекс обычно представляет наиболее быстро изменяющееся местоположение в памяти, в отличие от Fortran или IDL, где первый индекс представляет наиболее быстро изменяющееся местоположение в памяти. Эта разница представляет собой большую потенциальную возможность для путаницы.

Другие варианты индексирования

Можно срезать и изменять шаг массивов для извлечения массивов с тем же числом размерностей, но разного размера по сравнению с исходным. Срезы и изменение шага работают точно так же, как и для списков и кортежей, за исключением того, что они могут быть применены и к нескольким размерностям. Несколько примеров лучше всего иллюстрируют это:

>>> x = np.arange(10)
>>> x[2:5]
array([2, 3, 4])
>>> x[:-7]
array([0, 1, 2])
>>> x[1:7:2]
array([1, 3, 5])
>>> y = np.arange(35).reshape(5,7)
>>> y[1:5:2,::3]
array([[ 7, 10, 13],
       [21, 24, 27]])

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

Можно индексировать массивы с помощью других массивов для выбора списков значений из массивов в новые массивы. Существует два разных способа достижения этого. Один использует один или несколько массивов значений индексов. Другой включает в себя предоставление булевого массива соответствующей формы для указания значений, которые будут выбраны. Массивы индексов являются очень мощным инструментом, позволяющим избежать циклов по отдельным элементам в массивах, а следовательно, значительно улучшить производительность.

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

Массивы индексов

Массивы NumPy могут быть индексированы другими массивами (или любым другим объектом, подобным последовательности, который может быть преобразован в массив, например, списки, за исключением кортежей; см. конец этого документа, чтобы понять, почему это так). Использование массивов индексов варьируется от простых и понятных случаев до сложных и труднопонимаемых. Во всех случаях с массивами индексов возвращается копия исходных данных, а не представление, как в случае со срезами.

Массивы индексов должны быть целочисленного типа. Каждое значение в массиве указывает, какое значение в массиве использовать вместо индекса. Чтобы проиллюстрировать:

>>> x = np.arange(10,1,-1)
>>> x
array([10,  9,  8,  7,  6,  5,  4,  3,  2])
>>> x[np.array([3, 3, 1, 8])]
array([7, 7, 9, 2])

Массив индексов, состоящий из значений 3, 3, 1 и 8 соответственно, создаёт массив длиной 4 (такой же, как и массив индексов), где каждый индекс заменяется значением, которое массив индексов имеет в индексируемом массиве.

Разрешены отрицательные значения, и они работают так же, как и с одиночными индексами или срезами:

>>> x[np.array([3,3,-3,8])]
array([7, 7, 4, 2])

Ошибка возникает, если значения индексов выходят за пределы границ:

>>> x[np.array([3, 3, 20, 8])]
<type 'exceptions.IndexError'>: index 20 out of bounds 0<=index<9

В общем случае, что возвращается при использовании массивов индексов, – это массив с такой же формой, как и массив индексов, но с типом и значениями индексируемого массива. Например, мы можем использовать многомерный массив индексов вместо:

>>> x[np.array([[1,1],[2,3]])]
array([[9, 9],
       [8, 7]])

Индексирование многомерных массивов

Ситуация усложняется при индексировании многомерных массивов, особенно с многомерными массивами индексов. Эти случаи, как правило, являются более необычными, но они разрешены и полезны для некоторых задач. Начнём с самого простого многомерного случая (используя массив y из предыдущих примеров):

>>> y[np.array([0,2,4]), np.array([0,1,2])]
array([ 0, 15, 30])

В этом случае, если массивы индексов имеют согласованную форму и существует массив индексов для каждой размерности индексируемого массива, полученный массив имеет такую же форму, как и массивы индексов, а значения соответствуют набору индексов для каждой позиции в массивах индексов. В этом примере первое значение индекса для обоих массивов индексов равно 0, и поэтому первое значение результирующего массива равно y[0,0]. Следующее значение – y[2,1], а последнее – y[4,2].

Если массивы индексов не имеют одинаковой формы, то происходит попытка их трансляции к одинаковой форме. Если их нельзя транслировать к одинаковой форме, возникает исключение:

>>> y[np.array([0,2,4]), np.array([0,1])]
<type 'exceptions.ValueError'>: shape mismatch: objects cannot be
broadcast to a single shape

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

>>> y[np.array([0,2,4]), 1]
array([ 1, 15, 29])

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

>>> y[np.array([0,2,4])]
array([[ 0,  1,  2,  3,  4,  5,  6],
       [14, 15, 16, 17, 18, 19, 20],
       [28, 29, 30, 31, 32, 33, 34]])

Результат – создание нового массива, где каждое значение массива индексов выбирает один ряд из индексируемого массива, и результирующий массив имеет полученную форму (количество элементов индекса, размер строки).

Пример, где это может быть полезно, – таблица поиска цвета, где мы хотим отобразить значения изображения в тройки RGB для отображения. Таблица поиска может иметь форму (nlookup, 3). Индексирование такого массива изображением с формой (ny, nx) с типом данных = np.uint8 (или любым целочисленным типом, пока значения находятся в пределах таблицы поиска) приведёт к массиву формы (ny, nx, 3), где тройка значений RGB связана с каждым пиксельным расположением.

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

Булевы или «маскирующие» массивы индексов

Булевы массивы, используемые в качестве индексов, обрабатываются совершенно иначе, чем массивы индексов. Булевы массивы должны иметь такую же форму, как начальные размерности индексируемого массива. В самом простом случае булев массив имеет ту же форму:

>>> b = y>20
>>> y[b]
array([21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34])

В отличие от случая с целочисленными массивами индексов, в булевом случае результатом является одномерный массив, содержащий все элементы индексируемого массива, соответствующие всем истинным элементам булева массива. Элементы индексируемого массива всегда итерируются и возвращаются в порядке строк (в стиле C). Результат также идентичен y[np.nonzero(b)]. Как и в случае с массивами индексов, возвращается копия данных, а не представление, как в случае со срезами.

Результат будет многомерным, если у y больше размерностей, чем у b. Например:

>>> b[:,5] # use a 1-D boolean whose first dim agrees with the first dim of y
array([False, False, False,  True,  True])
>>> y[b[:,5]]
array([[21, 22, 23, 24, 25, 26, 27],
       [28, 29, 30, 31, 32, 33, 34]])

Здесь выбираются 4-я и 5-я строки из индексируемого массива и объединяются в двумерный массив.

В общем случае, когда булев массив имеет меньше размерностей, чем индексируемый массив, это эквивалентно y[b, …], что означает, что y индексируется b, за которым следуют столько двоеточий, сколько необходимо для заполнения ранга y. Таким образом, форма результата – одна размерность, содержащая количество истинных элементов булева массива, за которой следуют оставшиеся размерности индексируемого массива.

Например, использование двумерного булева массива формы (2,3) с четырьмя истинными элементами для выбора строк из трёхмерного массива формы (2,3,5) приводит к двумерному результату формы (4,5):

>>> x = np.arange(30).reshape(2,3,5)
>>> x
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, 24],
        [25, 26, 27, 28, 29]]])
>>> b = np.array([[True, True, False], [False, True, True]])
>>> x[b]
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29]])

Для получения более подробной информации обратитесь к справочной документации NumPy по индексированию массивов.

Комбинирование массивов индексов со срезами

Массивы индексов можно комбинировать со срезами. Например:

>>> y[np.array([0,2,4]),1:3]
array([[ 1,  2],
       [15, 16],
       [29, 30]])

По сути, срез преобразуется в массив индексов np.array([[1,2]]) (форма (1,2)), который транслируется с массивом индексов для получения результирующего массива формы (3,2).

Аналогично, срезы могут быть объединены с транслируемыми булевыми индексами:

>>> b = y > 20
>>> b
array([[False, False, False, False, False, False, False],
      [False, False, False, False, False, False, False],
      [False, False, False, False, False, False, False],
      [ True,  True,  True,  True,  True,  True,  True],
      [ True,  True,  True,  True,  True,  True,  True]])
>>> y[b[:,5],1:3]
array([[22, 23],
       [29, 30]])

Инструменты структурного индексирования

Для облегчения соответствия форм массивов выражениям и в присваиваниях, объект np.newaxis может использоваться в индексах массивов для добавления новых размерностей размером 1. Например:

>>> y.shape
(5, 7)
>>> y[:,np.newaxis,:].shape
(5, 1, 7)

Обратите внимание, что в массиве нет новых элементов, просто увеличивается размерность. Это может быть полезно для объединения двух массивов, что в противном случае потребовало бы явных операций преобразования формы. Например:

>>> x = np.arange(5)
>>> x[:,np.newaxis] + x[np.newaxis,:]
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8]])

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

>>> z = np.arange(81).reshape(3,3,3,3)
>>> z[1,...,2]
array([[29, 32, 35],
       [38, 41, 44],
       [47, 50, 53]])

Это эквивалентно:

>>> z[1,:,:,2]
array([[29, 32, 35],
       [38, 41, 44],
       [47, 50, 53]])

Присваивание значений индексируемым массивам

Как упоминалось, можно выбрать подмножество массива для присваивания с использованием одиночного индекса, срезов и массивов индексов и масок. Присваиваемое значение индексируемому массиву должно быть согласованной формой (такой же формы или транслируемой к форме, которую создаёт индекс). Например, разрешено присваивать константу срезу:

>>> x = np.arange(10)
>>> x[2:7] = 1

или массив соответствующего размера:

>>> x[2:7] = np.arange(5)

Обратите внимание, что присваивания могут привести к изменениям, если присваиваются типы высшего порядка низшим (например, плавающие числа целым) или даже к исключениям (присваивание комплексных чисел плавающим или целым числам):

>>> x[1] = 1.2
>>> x[1]
1
>>> x[1] = 1.2j
<type 'exceptions.TypeError'>: can't convert complex to long; use
long(abs(z))

В отличие от некоторых ссылок (например, индексов массивов и масок), присваивания всегда производятся к исходным данным в массиве (поскольку иначе не имеет смысла!). Однако обратите внимание, что некоторые действия могут не работать так, как можно наивно ожидать. Этот конкретный пример часто вызывает удивление:

>>> x = np.arange(0, 50, 10)
>>> x
array([ 0, 10, 20, 30, 40])
>>> x[np.array([1, 1, 3, 1])] += 1
>>> x
array([ 0, 11, 20, 31, 40])

Где ожидается, что первое место будет увеличено на 3. Фактически, оно будет увеличено только на 1. Причина в том, что из исходного (как временного) извлекается новый массив, содержащий значения 1, 1, 3, 1, затем к временному значению добавляется 1, а затем временный присваивается обратно исходному массиву. Таким образом, значение массива в x[1]+1 присваивается x[1] трижды, а не увеличивается трижды.

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

Синтаксис индексов очень мощный, но ограниченный при работе с переменным количеством индексов. Например, если вы хотите написать функцию, которая может обрабатывать аргументы с различным количеством измерений, не записывая специального кода для каждого возможного числа измерений, как это можно сделать? Если в индекс передается кортеж, кортеж будет интерпретироваться как список индексов. Например (используя предыдущее определение массива z):

>>> indices = (1,1,1,1)
>>> z[indices]
40

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

Срезы могут быть указаны в программах с помощью функции slice() в Python. Например:

>>> indices = (1,1,1,slice(0,2)) # same as [1,1,1,0:2]
>>> z[indices]
array([39, 40])

Аналогичным образом, эллипсис может быть указан в коде с помощью объекта Ellipsis:

>>> indices = (1, Ellipsis, 1) # same as [1,...,1]
>>> z[indices]
array([[28, 31, 34],
       [37, 40, 43],
       [46, 49, 52]])

По этой причине можно использовать результат функции np.nonzero() непосредственно в качестве индекса, так как она всегда возвращает кортеж массивов индексов.

Из-за специального обращения с кортежами они не преобразуются автоматически в массив, как это делается со списком. В качестве примера:

>>> z[[1,1,1,1]] # produces a large array
array([[[[27, 28, 29],
         [30, 31, 32], ...
>>> z[(1,1,1,1)] # returns a single value
40