Как работает python numpy.where()?

Я играю с numpy и копаю документацию, и я наткнулся на какую-то магию. А именно я говорю о numpy.where():

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

Как они достигают внутри, что вы можете передать что-то вроде x > 5 в метод? Я думаю, что это имеет какое-то отношение к __gt__, но я ищу подробное объяснение.

Ответ 1

Как они достигают внутри, что вы можете передать что-то вроде x > 5 в метод?

Короткий ответ заключается в том, что они этого не делают.

Любая логическая операция в массиве numpy возвращает логический массив. (т.е. __gt__, __lt__ и т.д. все возвращают булевы массивы, где данное условие истинно).

например.

x = np.arange(9).reshape(3,3)
print x > 5

дает:

array([[False, False, False],
       [False, False, False],
       [ True,  True,  True]], dtype=bool)

Это та же самая причина, почему что-то вроде if x > 5: вызывает значение ValueError, если x является массивом numpy. Это массив значений True/False, а не одно значение.

Кроме того, массивы numpy могут быть проиндексированы булевыми массивами. Например. x[x>5] дает [6 7 8], в этом случае.

Честно говоря, это довольно редко, что вам действительно нужно numpy.where, но он просто возвращает указатели, в которых булев массив равен True. Обычно вы можете делать то, что вам нужно, с простым булевым индексированием.

Ответ 2

Старый ответ это немного сбивает с толку. Он дает вам МЕСТНОСТИ (все из них), где ваше утверждение истинно.

так:

>>> a = np.arange(100)
>>> np.where(a > 30)
(array([31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
       48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
       65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
       82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
       99]),)
>>> np.where(a == 90)
(array([90]),)

a = a*40
>>> np.where(a > 1000)
(array([26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
       43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
       60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
       94, 95, 96, 97, 98, 99]),)
>>> a[25]
1000
>>> a[26]
1040

Я использую его как альтернативу list.index(), но он также имеет много других применений. Я никогда не использовал его с 2D-массивами.

http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html

Новый ответ Кажется, человек задавал нечто более фундаментальное.

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

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

a > 1000
array([False, False, False, False, False, 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,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True`,  True,  True,  True,  True,  True,  True,  True,  True,  True], dtype=bool)`

Это делается путем перегрузки метода "__gt__". Например:

>>> class demo(object):
    def __gt__(self, item):
        print item


>>> a = demo()
>>> a > 4
4

Как вы можете видеть, "a > 4" был действительным кодом.

Здесь вы можете получить полный список и документацию обо всех перегруженных функциях: http://docs.python.org/reference/datamodel.html

Что-то невероятное, так это просто сделать это. ВСЕ операции в python выполняются таким образом. Высказывание a > b эквивалентно a. gt (b)!

Ответ 3

np.where возвращает кортеж длины, равный размеру numpy ndarray, на который он вызывается (другими словами, ndim), и каждый элемент кортежа является numpy ndarray индексов всех этих значений в начальном ndarray, для которого выполняется условие правда. (Пожалуйста, не путайте размер с формой)

Например:

x=np.arange(9).reshape(3,3)
print(x)
array([[0, 1, 2],
      [3, 4, 5],
      [6, 7, 8]])
y = np.where(x>4)
print(y)
array([1, 2, 2, 2], dtype=int64), array([2, 0, 1, 2], dtype=int64))

y является кортежем длины 2, потому что x.ndim равно 2. Первый элемент в кортеже содержит номера строк всех элементов больше 4, а второй элемент содержит номера столбцов всех элементов больше 4. Как вы можете видеть, [1, 2,2,2] соответствует номерам строк 5,6,7,8 и [2,0,1,2] соответствует номерам столбцов 5,6,7,8. Обратите внимание, что ndarray пересекается по первому размеру ( построчно).

По аналогии,

x=np.arange(27).reshape(3,3,3)
np.where(x>4)

вернет кортеж длины 3, потому что x имеет 3 измерения.

Но ждите, там больше к np.where!

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

x=np.arange(9).reshape(3,3)
y = np.where(x>4, 1, 0)
print(y)
array([[0, 0, 0],
   [0, 0, 1],
   [1, 1, 1]])