在您的特定情况下的最佳方法是将您的两个标准更改为一个标准：

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

字符串
它只创建一个布尔数组，在我看来更容易阅读，因为它说，* 是dist在dr或r？* （虽然我会将r重新定义为感兴趣区域的中心，而不是开始，所以r = r + dr/2.）但这并没有回答你的问题。

您问题的答案：

如果你只是想过滤掉dists中不符合你的标准的元素，你实际上并不需要where：

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)

型
现在你可以在组合的boolean数组上调用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. ])

型
或者简单地使用fancy indexing用布尔数组索引原始数组

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

型

公认的答案很好地解释了这个问题。然而，应用多个条件的更Numpythonic的方法是使用numpy logical functions。在这种情况下，可以使用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中阅读这个answer或类似的Q/A。

更新

一个用户问，为什么需要在括号内给出（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)

型
因为这里没有括号，所以按位运算符（&）在这里变得困惑，你甚至要求它获得逻辑与，因为在运算符优先级表中，如果你看到，&优先于<或>运算符。这是从最低优先级到最高优先级的表。
x1c 0d1x的数据
它甚至没有执行<和>操作，而是被要求执行逻辑AND操作。这就是为什么它给出了这个错误。
您可以查看以下链接以了解更多信息：算符优先

现在到案例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)

型
其中，对于给定的情况，无论何处True，都分配第一个值（即这里是“yo”），如果是False，则另一个（即（保留原件）。
就这样。我希望我已经把问题解释清楚了。

要让np.where()在多个条件下工作，只需执行以下操作：

np.where((condition 1) & (condition 2)) # for and
np.where((condition 1) | (condition 2)) # for or

字符串
我知道这重复了一些其他的答案，但是我把这个简单的答案放在这里，因为人们仍然想知道，“为什么我会得到关于The truth value of an array with more than one element is ambiguous的恼人的错误消息”，他们被非常冗长和复杂的答案所迷惑，这些答案解决了原始帖子的一些专业性质。
现在，至于为什么当你使用and而不是&时numpy会崩溃，我不会在这里回答这个问题。它只是这样做：）看到其他答案在这里的解释。这似乎是他们应该修复的东西，而不是为了一致性而强迫它。或者至少他们应该做一个更好的错误消息。：）

我喜欢使用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进行清除输出。

这应该可以工作：

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))
# Output: (array([2, 3, 4]),)

字符串
您可以查看Logic functions了解更多详细信息。

试试看：

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

字符串

我已经算出了这个简单的例子

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]

字符串