[Numpy-discussion] Why are empty arrays False?

Michael Lamparski diagonaldevice at gmail.com
Sat Aug 19 01:04:56 EDT 2017


> More importantly though, allowing your proposed semantics would cause a
lot of silent bugs in code like `if arr == value`, which would be silently
true of array inputs. We already diverge from python on what == means, so I
see no reason to match the normal semantics of bool.

Eric hits the nail right on the head here. (er, ahh, you're both Eric!)
And this gets worse; not only would `a == b` be true, but so would `a !=
b`! For the vast majority of arrays, `bool(x != x)` would be True!

I can resonate with Eric F's feelings, because to be honest, I've never
been a big fan of the fact that comparison operators return arrays in the
first place.  That said... it's a difficult design question, and I can
respect the decision that was made; there certainly are a large variety of
circumstances where broadcasting these operations are useful. On the other
hand, it is a decision that comes with implications that cannot be ignored
in many other parts of the library, and truthiness of arrays is one of them.

> I'd be tentatively in favor of deprecating bool(array([1]) with a warning
asking for `.squeeze()` to be used, since this also hides a (smaller) class
of bugs.

I can get behind this as well, though I just keep wondering in the back of
my mind whether there's some tricky but legitimate use case that I'm not
thinking about, where arrays of size 1 just happen to have a natural
tendency to arise.

On Sat, Aug 19, 2017, 10:34 Eric Firing <efiring at hawaii.edu> wrote:

> On 2017/08/18 11:45 AM, Michael Lamparski wrote:
> > Greetings, all.  I am troubled.
> >
> > The TL;DR is that `bool(array([])) is False` is misleading, dangerous,
> > and unnecessary. Let's begin with some examples:
> >
> >  >>> bool(np.array(1))
> > True
> >  >>> bool(np.array(0))
> > False
> >  >>> bool(np.array([0, 1]))
> > ValueError: The truth value of an array with more than one element is
> > ambiguous. Use a.any() or a.all()
> >  >>> bool(np.array([1]))
> > True
> >  >>> bool(np.array([0]))
> > False
> >  >>> bool(np.array([]))
> > False
> >
> > One of these things is not like the other.
> >
> > The first three results embody a design that is consistent with some of
> > the most fundamental design choices in numpy, such as the choice to have
> > comparison operators like `==` work elementwise.  And it is the only
> > such design I can think of that is consistent in all edge cases. (see
> > footnote 1)
> >
> > The next two examples (involving arrays of shape (1,)) are a
> > straightforward extension of the design to arrays that are isomorphic to
> > scalars.  I can't say I recall ever finding a use for this feature...
> > but it seems fairly harmless.
> >
> > So how about that last example, with array([])?  Well... it's /kind of/
> > like how other python containers work, right? Falseness is emptiness
> > (see footnote 2)...  Except that this is actually *a complete lie*, due
> > to /all of the other examples above/!
>
> I don't agree.  I think the consistency between bool([]) and
> bool(array([])) is worth preserving.  Nothing you have shown is
> inconsistent with "Falseness is emptiness", which is quite fundamental
> in Python.  The inconsistency is in distinguishing between 1 element and
> more than one element.  To be consistent, bool(array([0])) and
> bool(array([0, 1])) should both be True.  Contrary to the ValueError
> message, there need be no ambiguity, any more than there is an ambiguity
> in bool([1, 2]).
>
> Eric
> _______________________________________________
> NumPy-Discussion mailing list
> NumPy-Discussion at python.org
> https://mail.python.org/mailman/listinfo/numpy-discussion
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/numpy-discussion/attachments/20170819/5108dd99/attachment-0001.html>


More information about the NumPy-Discussion mailing list