Question

Numpy的logical_or函数只需要比较两个数组。如何找到两个以上数组的并集？（关于Numpy的logical_and可以问同样的问题，并获得两个以上数组的交集。）

Answer 1

如果您询问的是numpy.logical_or，那么，正如文档明确指出的那样，唯一的参数是x1, x2，可选out：

numpy. logical_or （ x1, x2[, out] ）= <ufunc 'logical_or'>

您当然可以将多个logical_or调用链接在一起，如下所示：

>>> x = np.array([True, True, False, False])
>>> y = np.array([True, False, True, False])
>>> z = np.array([False, False, False, False])
>>> np.logical_or(np.logical_or(x, y), z)
array([ True,  True,  True,  False], dtype=bool)

在NumPy中推广这种链接的方法是使用reduce：

>>> np.logical_or.reduce((x, y, z))
array([ True,  True,  True,  False], dtype=bool)

当然，如果您有一个多维数组而不是单独的数组，这也会有效 - 事实上，这就是意味着的使用方式：

>>> xyz = np.array((x, y, z))
>>> xyz
array([[ True,  True, False, False],
       [ True, False,  True, False],
       [False, False, False, False]], dtype=bool)
>>> np.logical_or.reduce(xyz)
array([ True,  True,  True,  False], dtype=bool)

但是，三个等长1D数组的元组是NumPy术语中的 array_like ，可以用作2D数组。

在NumPy之外，你也可以使用Python的reduce：

>>> functools.reduce(np.logical_or, (x, y, z))
array([ True,  True,  True,  False], dtype=bool)

然而，与NumPy的reduce不同，Python并不经常需要。对于大多数情况，有一种更简单的方法可以做 - 例如，将多个Python or运算符链接在一起，而不是reduce超过operator.or_，只需使用any。当不是时，使用显式循环通常更具可读性。

事实上，NumPy的any也可以用于此案例，尽管它并不是那么简单;如果你没有明确地给它一个轴，你最终会得到一个标量而不是一个数组。所以：

>>> np.any((x, y, z), axis=0)
array([ True,  True,  True,  False], dtype=bool)

正如您所料，logical_and是相似的 - 您可以将其链接起来，np.reduce它，functools.reduce它，或用axis替换all

其他操作如all怎么样？同样，相同的交易...除了在这种情况下没有适用的any / odd - 类型函数。（你会怎么称呼它？{{1}}？）

Answer 2

由于布尔代数根据定义是可交换的和关联的，因此a，b和c的布尔值的以下语句或等价物。

a or b or c

(a or b) or c

a or (b or c)

(b or a) or c

所以，如果你有一个＆＃34; logical_or＆＃34;这是二元的，你需要传递三个参数（a，b和c），你可以调用

logical_or(logical_or(a, b), c)

logical_or(a, logical_or(b, c))

logical_or(c, logical_or(b, a))

或者你喜欢的任何排列。

回到python，如果你想测试一个条件（由一个函数test产生，它接受一个被测试者并返回一个布尔值）是否适用于a或b或c或列表L的任何元素，你通常使用

any(test(x) for x in L)

Answer 3

如果有人仍然需要这个 - 假设您有三个具有相同形状的布尔数组a，b，c，这将给出and元素：< / p>

a * b * c

这会给or：

a + b + c

这是你想要的吗？堆叠大量logical_and或logical_or是不切实际的。

Answer 4

使用sum函数：

a = np.array([True, False, True])
b = array([ False, False,  True])
c = np.vstack([a,b,b])

Out[172]: 
array([[ True, False,  True],
   [False, False,  True],
   [False, False,  True]], dtype=bool)

np.sum(c,axis=0)>0
Out[173]: array([ True, False,  True], dtype=bool)

Answer 5

基于abarnert对n维案例的回答：

TL; DR：np.logical_or.reduce(np.array(list))

Answer 6

我使用这种解决方法，可以将其扩展到n个数组：

>>> a = np.array([False, True, False, False])
>>> b = np.array([True, False, False, False])
>>> c = np.array([False, False, False, True])
>>> d = (a + b + c > 0) # That's an "or" between multiple arrays
>>> d
array([ True,  True, False,  True], dtype=bool)

Answer 7

我尝试了以下三种不同的方法来获取大小为 n k 个数组的列表 l 的logical_and >：

使用递归numpy.logical_and（请参见下文）
使用numpy.logical_and.reduce(l)
使用numpy.vstack(l).all(axis=0)

然后，我对logical_or函数执行了相同的操作。令人惊讶的是，递归方法是最快的方法。

import numpy
import perfplot

def and_recursive(*l):
    if len(l) == 1:
        return l[0].astype(bool)
    elif len(l) == 2:
        return numpy.logical_and(l[0],l[1])
    elif len(l) > 2:
        return and_recursive(and_recursive(*l[:2]),and_recursive(*l[2:]))

def or_recursive(*l):
    if len(l) == 1:
        return l[0].astype(bool)
    elif len(l) == 2:
        return numpy.logical_or(l[0],l[1])
    elif len(l) > 2:
        return or_recursive(or_recursive(*l[:2]),or_recursive(*l[2:]))

def and_reduce(*l):
    return numpy.logical_and.reduce(l)

def or_reduce(*l):
    return numpy.logical_or.reduce(l)

def and_stack(*l):
    return numpy.vstack(l).all(axis=0)

def or_stack(*l):
    return numpy.vstack(l).any(axis=0)

k = 10 # number of arrays to be combined

perfplot.plot(
    setup=lambda n: [numpy.random.choice(a=[False, True], size=n) for j in range(k)],
    kernels=[
        lambda l: and_recursive(*l),
        lambda l: and_reduce(*l),
        lambda l: and_stack(*l),
        lambda l: or_recursive(*l),
        lambda l: or_reduce(*l),
        lambda l: or_stack(*l),
    ],
    labels = ['and_recursive', 'and_reduce', 'and_stack', 'or_recursive', 'or_reduce', 'or_stack'],
    n_range=[2 ** j for j in range(20)],
    logx=True,
    logy=True,
    xlabel="len(a)",
    equality_check=None
)

以下是k = 4的性能。

下面是k = 10的性能。

对于更高的n来说，似乎还有一个恒定的时间开销。

Answer 8

如果您想要一个简短的（可能不是最佳的）函数来对多维布尔掩码执行逻辑 AND，您可以使用这个递归 lambda 函数：

masks_and = lambda *masks : masks[0] if len(masks) == 1 else masks_and(np.logical_and(masks[0], masks[-1]), *masks[1:-1])
result = masks_and(mask1, mask2, ...)

假设顺序也很重要，您还可以将 lambda 函数泛化为将任何具有分配属性（例如乘法/与、和/或等）的运算符（2 个参数的函数）应用到任何像这样的对象:

fn2args_reduce = lambda fn2args, *args : args[0] if len(args) == 1 else fn2args_reduce(fn2args, fn2args(args[0], args[1]), *args[2:])
result = fn2args_reduce(np.dot, matrix1, matrix2, ... matrixN)

它给你的结果和你使用 @ numpy 操作符一样）：

np.dot(...(np.dot(np.dot(matrix1, matrix2), matrix3)...), matrixN)

例如 fn2args_reduce(lambda a,b: a+b, 1,2,3,4,5) 给你 15 - 这些数字的总和（当然你有一个更有效的 sum 函数，但我喜欢它）。

对于包含 N 个参数的函数，更通用的模型可能如下所示：

fnNargs_reduce = lambda fnNargs, N, *args : args[0] if len(args) == 1 else fnNargs_reduce(fnNargs, N, fnNargs(*args[:N]), *args[N:])
fnNargs = lambda x1, x2, x3=neutral, ..., xN=neutral: x1 (?) x2 (?) ... (?) xN

其中中性意味着它是 (?) 运算符的中性元素，例如。 0 代表 +，1 代表 * 等

为什么？只是为了好玩:-)

多于两个参数的Numpy`logical_or`

8 个答案: