How does all() in python work on empty lists
"all" applied to an empty list is "vacuously true", as is easily confirmed:
>>> all([])
True
Similarly, "if 0 = 1 then the moon is square" is true. More generally, "all P are Q" -- if there are no P's then the statement is considered true, as it can be captured formally as "For all x, if x is P then x is Q". Ultimately, these are true because the conditional logical operator (if-then) evaluates to True whenever the antecedent (the first clause) is False: "if False then True" evaluates to True. Recall that "if A then B" is equivalent to "(not A) or B".
Added 1-2022
In the case of all
and Python lists, the boolean value of all(my_list)
is the value of
"for all items `x` in `my_list`, the value of `x` is truthy".
When my_list
is empty, that value is True. Again, "for all" and all
make no existence claim.
In Python pseudocode, all
works roughly like this:
val = True
for x in my_list:
if not x:
val = False
break
# assert val == all(my_list)
Consider a recursive definition of all
:
def all(L):
if L:
return L[0] and all(L[1:])
else:
???
If every element in L
is true, then it must be true that both the first item in L
is true, and that all(L[1:])
is true. This is easy to see for a list with several items, but what about a list with one item. Clearly, every item is true if the only item is true, but how does our recursive formulation work in that case? Defining all([])
to be true makes the algorithm work.
Another way to look at it is that for any list L
for which all(L)
is not true, we should be able to identify at least one element, a
, which is not true. However, there is no such a
in L
when L
is empty, so we are justified in saying that all([])
is true.
The same arguments work for any
. If any(L)
is true, we should be able to identify at least one element in L
that is true. But since we cannot for an empty list L
, we can say that any([])
is false. A recursive implementation of any
backs this up:
def any(L):
if L:
return L[0] or any(L[1:])
else:
return False
If L[0]
is true, we can return true without ever making the recursive call, so assume L[0]
is false. The only way we ever reach the base case is if no element of L
is true, so
we must return False
if we reach it.
It's true because for every element in the list, all 0 of them, they all are equal to 2.
You can think of all being implemented as:
def all(my_list, condition):
for a in my_list:
if not condition(a):
return False
return True
Whereas any is:
def any(my_list, condition):
for a in my_list:
if condition(a):
return True
return False
That is to say, all
is innocent until proven guilty, and any
is guilty until proven innocent.