Numpy, где функция несколько условий

У меня есть массив расстояний, называемых dists. Я хочу выбрать диски, которые находятся между двумя значениями. Для этого я написал следующую строку кода:

 dists[(np.where(dists >= r)) and (np.where(dists <= r + dr))]

Однако это выбирается только для условия

 (np.where(dists <= r + dr))

Если я выполняю команды последовательно, используя временную переменную, все работает нормально. Почему приведенный выше код не работает и как заставить его работать?

ура

Лучшим способом в вашем конкретном случае было бы просто изменить два ваших критерия на один критерий:

dists[abs(dists - r - dr/2.) <= dr/2.]

Он создает только один логический массив, и, на мой взгляд, его легче читать, потому что он говорит, находится distвнутри drили r? (Хотя я бы переопределил, rчто это центр вашей области интересов, а не начало, так что r = r + dr/2.) Но это не отвечает на ваш вопрос.

Ответ на ваш вопрос:
вам это действительно не нужно, whereесли вы просто пытаетесь отфильтровать элементы dists, не соответствующие вашим критериям:

dists[(dists >= r) & (dists <= r+dr)]

Потому что это &будет поэлементно and(круглые скобки необходимы).

Или, если вы whereпо какой-то причине хотите использовать , вы можете сделать:

 dists[(np.where((dists >= r) & (dists <= r + dr)))]

Почему:
Причина, по которой это не работает, заключается в том, что он np.whereвозвращает список индексов, а не логический массив. Вы пытаетесь попасть andмежду двумя списками чисел, которые, конечно, не имеют Trueожидаемых Falseзначений / . Если aи bявляются Trueзначениями, a and bвозвращается b. Так что, сказав что-то вроде, [0,1,2] and [2,3,4]вы просто получите [2,3,4]. Вот он в действии:

In [230]: dists = np.arange(0,10,.5)
In [231]: r = 5
In [232]: dr = 1

In [233]: np.where(dists >= r)
Out[233]: (array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]),)

In [234]: np.where(dists <= r+dr)
Out[234]: (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]),)

In [235]: np.where(dists >= r) and np.where(dists <= r+dr)
Out[235]: (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]),)

То, что вы ожидали сравнить, было просто логическим массивом, например

In [236]: dists >= r
Out[236]: 
array([False, False, False, False, False, False, False, False, False,
       False,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True], dtype=bool)

In [237]: dists <= r + dr
Out[237]: 
array([ True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True, False, False, False, False, False,
       False, False], dtype=bool)

In [238]: (dists >= r) & (dists <= r + dr)
Out[238]: 
array([False, False, False, False, False, False, False, False, False,
       False,  True,  True,  True, False, False, False, False, False,
       False, False], dtype=bool)

Теперь вы можете вызвать np.whereобъединенный логический массив:

In [239]: np.where((dists >= r) & (dists <= r + dr))
Out[239]: (array([10, 11, 12]),)

In [240]: dists[np.where((dists >= r) & (dists <= r + dr))]
Out[240]: array([ 5. ,  5.5,  6. ])

Или просто проиндексируйте исходный массив с помощью логического массива, используя причудливую индексацию

In [241]: dists[(dists >= r) & (dists <= r + dr)]
Out[241]: array([ 5. ,  5.5,  6. ])

Принятый ответ достаточно хорошо объяснил проблему. Однако более Numpythonic подход к применению нескольких условий - это использование numpy логических функций . В этом случае вы можете использовать np.logical_and:

np.where(np.logical_and(np.greater_equal(dists,r),np.greater_equal(dists,r + dr)))

Здесь стоит отметить одну интересную вещь; обычный способ использования OR и AND тоже будет работать в этом случае, но с небольшими изменениями. Вместо «и» и вместо «или» лучше используйте амперсанд (&) и оператор конвейера (|), и он будет работать.

Когда мы используем 'и' :

ar = np.array([3,4,5,14,2,4,3,7])
np.where((ar>3) and (ar<6), 'yo', ar)

Output:
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Когда мы используем амперсанд (&) :

ar = np.array([3,4,5,14,2,4,3,7])
np.where((ar>3) & (ar<6), 'yo', ar)

Output:
array(['3', 'yo', 'yo', '14', '2', 'yo', '3', '7'], dtype='<U11')

И это то же самое в случае, когда мы пытаемся применить несколько фильтров в случае pandas Dataframe. Теперь рассуждения, лежащие в основе этого, должны что-то делать с логическими операторами и побитовыми операторами, и для большего понимания того же я предлагаю пройти этот ответ или аналогичный вопрос / ответ в stackoverflow.

ОБНОВИТЬ

Пользователь спросил, зачем нужно указывать (ar> 3) и (ar <6) внутри скобок. Ну вот в чем дело. Прежде чем я начну говорить о том, что здесь происходит, нужно знать о приоритете операторов в Python.

Подобно тому, что такое BODMAS, python также отдает приоритет тому, что должно быть выполнено в первую очередь. Сначала выполняются элементы внутри скобок, а затем начинает работать побитовый оператор. Ниже я покажу, что происходит в обоих случаях, когда вы используете и не используете "(", ")".

Случай 1:

np.where( ar>3 & ar<6, 'yo', ar)
np.where( np.array([3,4,5,14,2,4,3,7])>3 & np.array([3,4,5,14,2,4,3,7])<6, 'yo', ar)

Поскольку здесь нет скобок, побитовый оператор ( &) запутался здесь тем, что вы даже просите его получить логическое И, потому что в таблице приоритета операторов, если вы видите, &имеет приоритет над операторами <или >. Вот таблица от самого низкого до самого высокого приоритета.

Это даже не выполняя <и >операцию , и попросили , чтобы выполнить логическую операцию. Вот почему он дает эту ошибку.

Чтобы узнать больше о приоритетах операторов, перейдите по следующей ссылке.

Теперь к случаю 2:

Если вы все же используете скобу, вы ясно увидите, что происходит.

np.where( (ar>3) & (ar<6), 'yo', ar)
np.where( (array([False,  True,  True,  True, False,  True, False,  True])) & (array([ True,  True,  True, False,  True,  True,  True, False])), 'yo', ar)

Два массива True и False. И вы можете легко выполнить с ними операцию логического И. Что дает вам:

np.where( array([False,  True,  True, False, False,  True, False, False]),  'yo', ar)

И остальное, знаете ли, np.where, для заданных случаев, где True, присваивает первое значение (т.е. здесь 'yo'), а если False, другое (то есть здесь, сохраняя оригинал).

Вот и все. Надеюсь, я хорошо объяснил вопрос.

Мне нравится использовать np.vectorizeдля таких задач. Учтите следующее:

>>> # function which returns True when constraints are satisfied.
>>> func = lambda d: d >= r and d<= (r+dr) 
>>>
>>> # Apply constraints element-wise to the dists array.
>>> result = np.vectorize(func)(dists) 
>>>
>>> result = np.where(result) # Get output.

Вы также можете использовать np.argwhereвместо np.whereдля четкого вывода. Но это ваш звонок :)

Надеюсь, поможет.

Пытаться:

np.intersect1d(np.where(dists >= r)[0],np.where(dists <= r + dr)[0])

Это должно работать:

dists[((dists >= r) & (dists <= r+dr))]

Самый элегантный способ ~~

Пытаться:

import numpy as np
dist = np.array([1,2,3,4,5])
r = 2
dr = 3
np.where(np.logical_and(dist> r, dist<=r+dr))

Выход: (массив ([2, 3]),)

Подробнее см. В разделе « Логические функции» .

Я разработал этот простой пример

import numpy as np

ar = np.array([3,4,5,14,2,4,3,7])

print [X for X in list(ar) if (X >= 3 and X <= 6)]

>>> 
[3, 4, 5, 4, 3]