Numpy `logical_or` for more than two arguments

Question

If you're asking about numpy.logical_or, then no, as the docs explicitly say, the only parameters are x1, x2, and optionally out:

numpy.logical_or(x1, x2[, out]) = <ufunc 'logical_or'>

---

You can of course chain together multiple logical_or calls like this:

>>> 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)

---

The way to generalize this kind of chaining in NumPy is with reduce:

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

And of course this will also work if you have one multi-dimensional array instead of separate arrays—in fact, that's how it's meant to be used:

>>> 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)

But a tuple of three equal-length 1D arrays is an array_like in NumPy terms, and can be used as a 2D array.

---

Outside of NumPy, you can also use Python's reduce:

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

However, unlike NumPy's reduce, Python's is not often needed. For most cases, there's a simpler way to do things—e.g., to chain together multiple Python or operators, don't reduce over operator.or_, just use any. And when there isn't, it's usually more readable to use an explicit loop.

And in fact NumPy's any can be used for this case as well, although it's not quite as trivial; if you don't explicitly give it an axis, you'll end up with a scalar instead of an array. So:

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

---

As you might expect, logical_and is similar—you can chain it, np.reduce it, functools.reduce it, or substitute all with an explicit axis.

What about other operations, like logical_xor? Again, same deal… except that in this case there is no all/any-type function that applies. (What would you call it? odd?)

In case someone still need this - Say you have three Boolean arrays a, b, c with the same shape, this gives and element-wise:

a * b * c

this gives or:

a + b + c

Is this what you want? Stacking a lot of logical_and or logical_or is not practical.

Building on abarnert's answer for n-dimensional case:

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

As boolean algebras are both commutative and associative by definition, the following statements or equivalent for boolean values of a, b and c.

a or b or c

(a or b) or c

a or (b or c)

(b or a) or c

So if you have a "logical_or" which is dyadic and you need to pass it three arguments (a, b, and c), you can call

logical_or(logical_or(a, b), c)

logical_or(a, logical_or(b, c))

logical_or(c, logical_or(b, a))

or whatever permutation you like.

---

Back to python, if you want to test whether a condition (yielded by a function test that takes a testee and returns a boolean value) applies to a or b or c or any element of list L, you normally use

any(test(x) for x in L)