How do Python's any and all functions work?
Question: I'm trying to understand how the `any()` and `all()` Python built-in functions
work.

I'm trying to compare the tuples so that if any value is different then it
will return `True` and if they are all the same it will return `False`. How
are they working in this case to return [False, False, False]?

`d` is a `defaultdict(list)`.

    
    
    print d['Drd2']
    # [[1, 5, 0], [1, 6, 0]]
    print list(zip(*d['Drd2']))
    # [(1, 1), (5, 6), (0, 0)]
    print [any(x) and not all(x) for x in zip(*d['Drd2'])]
    # [False, False, False]
    

To my knowledge, this should output

    
    
    # [False, True, False]
    

since (1,1) are the same, (5,6) are different, and (0,0) are the same.

**Why is it evaluating to False for all tuples?**


Answer: You can roughly think of `any` and `all` as series of logical `or` and `and`
operators, respectively.

**any**

`any` will return `True` when **atleast one of the elements** is Truthy. Read
about [Truth Value
Testing.](http://docs.python.org/2/library/stdtypes.html#truth-value-testing)

**all**

`all` will return `True` only when **all the elements** are Truthy.

**Truth table**

    
    
    +-----------------------------------------+---------+---------+
    |                                         |   any   |   all   |
    +-----------------------------------------+---------+---------+
    | All Truthy values                       |  True   |  True   |
    +-----------------------------------------+---------+---------+
    | All Falsy values                        |  False  |  False  |
    +-----------------------------------------+---------+---------+
    | One Truthy value (all others are Falsy) |  True   |  False  |
    +-----------------------------------------+---------+---------+
    | One Falsy value (all others are Truthy) |  True   |  False  |
    +-----------------------------------------+---------+---------+
    | Empty Iterable                          |  False  |  True   |
    +-----------------------------------------+---------+---------+
    

**Note 1:** The empty iterable case is explained in the official
documentation, like this

[**`any`**](https://docs.python.org/2/library/functions.html#any)

> Return `True` if any element of the iterable is true. **If the iterable is
> empty, return`False`**

Since none of the elements is true, it returns `False` in this case.

[**`all`**](https://docs.python.org/2/library/functions.html#all)

> Return `True` if all elements of the iterable are true (**or if the iterable
> is empty**).

Since none of the elements is false, it returns `True` in this case.

* * *

**Note 2:**

Another important thing to know about `any` and `all` is, it will short-
circuit the execution, the moment they know the result. The advantage is,
entire iterable need not be consumed. For example,

    
    
    >>> multiples_of_6 = (not (i % 6) for i in range(1, 10))
    >>> any(multiples_of_6)
    True
    >>> list(multiples_of_6)
    [False, False, False]
    

Here, `(not (i % 6) for i in range(1, 10))` is a generator expression which
returns `True` if the current number within 1 and 9 is a multiple of 6. `any`
iterates the `multiples_of_6` and when it meets `6`, it finds a Truthy value,
so it immediately returns `True`, and rest of the `multiples_of_6` is not
iterated. That is what we see when we print `list(multiples_of_6)`, the result
of `7`, `8` and `9`.

This excellent thing is used very cleverly in [this
answer](http://stackoverflow.com/a/16801605/1903116).

* * *

With this basic understanding, if we look at your code, you do

    
    
    any(x) and not all(x)
    

which makes sure that, atleast one of the values is Truthy but not all of
them. That is why it is returning `[False, False, False]`. If you really
wanted to check if both the numbers are not the same,

    
    
    print [x[0] != x[1] for x in zip(*d['Drd2'])]
    

