How does all() in python work on empty lists

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.

"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.

From office documents.

all(iterable)
Return True if all elements of the iterable are true (or if the iterable is empty). Equivalent to:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

New in version 2.5.

any(iterable)
Return True if any element of the iterable is true. If the iterable is empty, return False. Equivalent to:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

New in version 2.5.