Python Topics : How to Use all()
Evaluating the Truth Value of Items in Iterables
used to determine if all the items in an iterable are truthy 
>>> def all_true(iterable):
...     for item in iterable:
...         if not item:
...             return False
...     return True
...
loop is broken when not item is True
no need to continue checking values
all() works the same way as all_true
all() is written in C for performance

to perform truth value testing on objects Python's rules for objects which can be evaluated as False

  • inherently negative constants, like None and False
  • numeric types with a zero value, like 0, 0.0, 0j, Decimal("0"), and Fraction(0, 1)
  • empty sequences and collections, like "", (), [], {}, set(), and range(0)
    all() will return true because nothing is False
  • Objects that implement .__bool__() with a return value of False or .__len__() with a return value of 0
Getting Started With Python's all()
ConditionResult
all items evaluate as trueTrue
all items evaluate as falseFalse
one or more items evaluate as falseFalse
the input iterable is emptyTrue
Using all() With Different Iterable Types
Sequences
no real difference between lists and other sequence data types 
>>> # With tuples
>>> all((1, 2, 3))
True
>>> all((0, 1, 2, 3))
False
>>> all(())
True
>>> all(tuple())
True

>>> # With range objects
>>> all(range(10))
False
>>> all(range(1, 11))
True
>>> all(range(0))
True
all(range(10)) returns False because it contains zero
all(range(0)) returns true because the range is empty

Dictionaries
using all() with the .items() method of a dictionary does nothing
method returns key-value pairs as two-items tuples
tuples will always evaluate to true in Python

if a dictionary is passed directly as an argument, all() checks the truthiness of the keys 

>>> all({"gold": 1, "silver": 2, "bronze": 3})
True

>>> all({0: "zero", 1: "one", 2: "two"})
False
can use all() with <dictionary>.keys() and lt;dictionary>.values()
Using all() With List Comprehensions and Generator Expressions

can use all() with list comprehensions and generator expressions

Using all() with List Comprehensions
leverage all() by using a predicate function that tests for the desired property 
all([predicate(item) for item in iterable])
the list comprehension uses predicate() to test each item in iterable for a given property
the call to all() reduces the resulting list to a single True or False value 
>>> import math

>>> def is_prime(n):
...     if n <= 1:
...         return False
...     for i in range(2, math.isqrt(n) + 1):
...         if n % i == 0:
...             return False
...     return True
...

>>> numbers = [2, 3, 5, 7, 11]
>>> all([is_prime(x) for x in numbers])
True

>>> numbers = [2, 4, 6, 8, 10]
>>> all([is_prime(x) for x in numbers])
False
above combines all() with a list comprehension
the comprehension uses the is_prime() predicate function to test each value in numbers for primality
the resulting list will contain Boolean values (True or False) for the result of every check
then all() gets this list as an argument and processes it to determine if all the numbers are prime or not

all() returns True with an empty iterable as an argument
this behavior can lead to wrong conclusions 

>>> numbers = []

>>> all([number < 0 for number in numbers])
True

>>> all([number == 0 for number in numbers])
True

>>> all([number > 0 for number in numbers])
True
above the calls to all() return true because the array is empty
can use the built-in len() function to get the number of items in the input iterable
if len() returns 0, then skip calling all() to process the empty input iterable
Using all() with Generator Expressions
list comprehensions produce a list to be used as an argument to all()
generator expressions will generate and yield items on demand
more efficient with long iterables 
# With a predicate
all(predicate(item) for item in iterable)

# With a condition
all(condition for item in iterable)
Comparing all() With the and Boolean Operator
Understanding Syntax Differences
iterable arguments to all() can be general expressions, Boolean expressions, or Python objects of any type
iterable can contain any number of objects

the and operator is a binary operator which connects two operands 

>>> all([True, False])
False
the operands in an and expression can be general expressions, Boolean expressions, or Python objects
can use multiple and operators to connect any number of operands

Returning Boolean Values vs Operands
all() returns a boolean
and returns an operand 
>>> all(["Hello!", 42, {}])
False
>>> "Hello!" and 42 and {}
{}

>>> all([1, 2, 3])
True
>>> 1 and 2 and 3
3

>>> all([0, 1, 2, 3])
False
>>> 0 and 1 and 2 and 3
0

>>> all([5 > 2, 1 == 1])
True
>>> 5 > 2 and 1 == 1
True
in the first snippet all() returns false because of the empty set in the list
and returns the last operand checked
the last example above returns True because 1 == 1 evaluates to True
index