Python all() Function

Spread the love

The all() function is a built-in Python utility that evaluates the truthiness of the elements within an iterable. Its name itself provides a hint towards its function: it returns True if all the elements of the given iterable are true, and False otherwise. If the iterable is empty, the function returns True. Its simplicity and usefulness make it an essential tool in a Python developer’s toolkit.




  • iterable: Any Python iterable object, such as a list, tuple, set, or dictionary.

Return Values:

  • True: If all elements in the given iterable are true.
  • False: If any element in the given iterable is false.
  • True: If the iterable is empty.

all( ) in Python with Lists

A list in Python is an ordered collection of items which can be of any type. These items can be numbers, strings, booleans, or even other lists, among other types. The all() function provides a way to evaluate the “truthiness” of these items in a compact manner.

When you pass a list as an argument to the all() function, it iterates over each item in the list. The function will return True only if every item in that list is truthy. If even one item is falsy, it will return False. And if the list is empty, all() will return True.

What Does “Truthy” and “Falsy” Mean?

In Python, an object is considered truthy if it evaluates to True in a boolean context. On the contrary, an object is deemed falsy if it evaluates to False. For lists, typical falsy values include:

  • The number 0
  • An empty string ""
  • The boolean value False
  • None

All other values are generally considered truthy.

Examples with Lists

Lists with Numbers:

print(all([1, 2, 3, 4]))       # Output: True, since all numbers are non-zero
print(all([0, 1, 2, 3]))       # Output: False, because of the presence of 0

Lists with Strings:

print(all(["Hello", "World"])) # Output: True, since both strings are non-empty
print(all(["", "World"]))      # Output: False, because of the empty string

Lists with Mixed Types:

print(all([1, "Hello", True])) # Output: True, since all elements are truthy
print(all([0, "Hello", True])) # Output: False, because of the 0

Nested Lists:

print(all([[1, 2], [3, 4]]))   # Output: True, as nested lists are truthy unless they are empty
print(all([[], [3, 4]]))       # Output: False, because of the empty nested list

Empty List:

print(all([]))                 # Output: True, by definition of the `all()` function

The all() function is an invaluable tool when working with lists in Python. It offers a concise and elegant way to quickly evaluate the truthiness of all elements within a list. By understanding its behavior with lists, developers can more efficiently perform checks and make decisions based on the entire dataset without having to write explicit loops or multiple conditional statements.

all( ) in Python with Tuples

The behavior of the all() function with tuples is identical to its behavior with lists. When passed a tuple, the all() function will iterate over each item:

  • It will return True if every item in the tuple is truthy.
  • It will return False if even a single item in the tuple is falsy.
  • If the tuple is empty, all() will return True.

Examples with Tuples

Tuples with Numbers:

print(all((1, 2, 3, 4)))        # Output: True, all numbers are non-zero.
print(all((0, 1, 2, 3)))        # Output: False, because of the presence of 0.

Tuples with Strings:

print(all(("Hello", "World")))  # Output: True, both strings are non-empty.
print(all(("", "World")))       # Output: False, because of the empty string.

Tuples with Mixed Types:

print(all((1, "Hello", True)))  # Output: True, since all elements are truthy.
print(all((0, "Hello", True)))  # Output: False, because of the 0.

Nested Tuples:

print(all(((1, 2), (3, 4))))    # Output: True, nested tuples are always truthy, regardless of their content.
print(all(((), (3, 4))))        # Output: False, because of the empty nested tuple.

Empty Tuple:

print(all(()))                  # Output: True, by definition of the `all()` function.

Points to Remember

The primary distinction between using all() with lists versus tuples lies not in the function’s behavior but in the characteristics of the data structures. Since tuples are immutable, they’re particularly suitable for scenarios where you want to ensure that the collection remains constant throughout its lifecycle.

all( ) in Python with Sets

Firstly, it’s crucial to understand what a set is. A set is an unordered collection of unique items. This means each item can appear in a set only once. Sets are mutable, meaning you can add or remove items after a set is created. Sets in Python can contain items of mixed types but cannot contain mutable items such as lists or dictionaries.

How does all( ) work with Sets?

Using all() with sets follows a similar logic as with lists or tuples. When you pass a set to the all() function:

  • It will return True if every item in the set is truthy.
  • It will return False if any item in the set is falsy.
  • For an empty set, all() will return True.

However, remember that sets don’t have repeated elements, so if a falsy value exists in a set, it can only exist once.

Examples with Sets

Sets with Numbers:

print(all({1, 2, 3, 4}))        # Output: True, all numbers are non-zero.
print(all({0, 1, 2, 3}))        # Output: False, because of the presence of 0.

Sets with Strings:

print(all({"Hello", "World"}))  # Output: True, both strings are non-empty.
print(all({"", "World"}))       # Output: False, because of the empty string.

Sets with Mixed Types:

print(all({1, "Hello", True}))  # Output: True, since all elements are truthy.
print(all({0, "Hello", False})) # Output: False, because of the 0 and the boolean `False`.

Empty Set:

print(all(set()))               # Output: True, an empty set passed to `all()` always returns True.

Things to Remember

While using sets with all(), remember:

  • Sets inherently remove duplicate values. So, if you have a collection with repeated truthy or falsy values, converting it to a set and then applying all() may produce different results than expected.
  • Since sets are unordered, the order in which items are evaluated by all() is not guaranteed, unlike lists or tuples. However, this does not affect the final result of all().

all( ) in Python with Dictionaries

Before diving into the all() function’s behavior with dictionaries, let’s quickly recap what a dictionary is. A dictionary in Python is an unordered collection of key-value pairs. Dictionaries are mutable, meaning that they can be modified after they are created. A dictionary’s keys are unique and can be of any immutable type, such as strings, numbers, or tuples, whereas its values can be of any data type.

How does all( ) work with Dictionaries?

When the all() function is used with a dictionary, it essentially operates on the dictionary’s keys, not its values. The behavior can be summarized as:

  • If all keys in the dictionary are truthy, all() will return True.
  • If any key in the dictionary is falsy, all() will return False.
  • If the dictionary is empty, all() will return True.

Examples with Dictionaries

Dictionaries with String Keys:

print(all({"key1": 1, "key2": 2}))       # Output: True, as both keys "key1" and "key2" are truthy.

Dictionaries with Mixed Key Types:

dict_example = {1: "one", "two": 2, (3, 4): "tuple_key"}
print(all(dict_example))                 # Output: True, all keys (1, "two", and (3, 4)) are truthy.

Dictionaries with Falsy Keys:

print(all({0: "zero", "one": 1}))        # Output: False, because one of the keys is 0, which is falsy.
print(all({"": "empty", "two": 2}))      # Output: False, because one key is an empty string, which is falsy.

Empty Dictionary:

print(all({}))                           # Output: True, an empty dictionary always results in True.

Points to Remember

When using the all() function with dictionaries:

  • Remember that it evaluates the truthiness of keys, not the values. So, even if a dictionary has falsy values, the all() function will return True as long as all the keys are truthy.
  • Dictionaries, by design, will not have duplicate keys. If there are repeated keys when initializing a dictionary, only the last key-value pair will be retained.

all( ) in Python with Strings

In Python, a string is a sequence of characters. It can be defined by enclosing characters in single (‘ ‘), double (” “), or triple (”’ ”’ or “”” “””) quotes. Strings are immutable, which means that once a string is defined, its content cannot be altered.

How does all( ) work with Strings?

When applied to a string, the all() function checks the truthiness of the string’s individual characters:

  • If all characters in the string are truthy, all() will return True.
  • If any character in the string is falsy, all() will return False.
  • For an empty string, all() will return True.

In the context of strings and characters, only the empty string ("") is considered falsy. All non-empty strings and all individual characters are considered truthy, irrespective of their content.

Examples with Strings

Non-Empty Strings:

print(all("Hello"))             # Output: True, as the string is non-empty.
print(all("World"))             # Output: True, as the string is non-empty.

Strings with Spaces or Special Characters: Remember that spaces, tabs, newlines, and other special characters are all truthy.

print(all(" "))                 # Output: True, as space is a truthy character.
print(all("\t"))                # Output: True, a tab character is also truthy.

Empty String:

print(all(""))                  # Output: True, this might seem counterintuitive, but an empty string passed to `all()` always returns True.

Strings with ‘0’ or ‘False’: The characters ‘0’ and the string “False” (or any of its characters) are truthy because they are non-empty strings or characters.

print(all("0"))                 # Output: True, because '0' as a character is truthy.
print(all("False"))             # Output: True, all individual characters in "False" are truthy.

Points to Remember

When using the all() function with strings:

  • Always remember that every non-empty character is truthy, regardless of its actual content or representation.
  • The empty string is a special case where the all() function will always return True.

all( ) function with Condition

When you want to determine if every element in a collection (like a list, tuple, or set) meets a certain condition, you can combine all() with a comprehension.

Using List Comprehension with all()

A common method is to use list comprehension. Here’s a basic structure:

all([condition(element) for element in collection])


Checking if all numbers in a list are positive:

numbers = [1, 5, 8, 3, 9]
result = all([num > 0 for num in numbers])
print(result)  # Output: True

Checking if all strings in a list have a particular length:

strings = ["apple", "banana", "cherry"]
result = all([len(s) == 6 for s in strings])
print(result)  # Output: False, because "apple" don't have a length of 6.

Using Generator Expressions for Efficiency

For large collections, it’s more memory-efficient to use a generator expression instead of a list comprehension. This is because a generator expression doesn’t create an intermediate list; it yields items on-the-fly:

all(condition(element) for element in collection)


numbers = [2, 4, 6, 8, 10]
result = all(num % 2 == 0 for num in numbers)
print(result)  # Output: True, because all numbers are even.

Points to Remember:

  1. Short-Circuiting: One benefit of using all() is short-circuiting. This means that as soon as all() finds a falsy value, it returns False without evaluating the rest of the items in the iterable. This can lead to performance benefits, especially with large iterables.
  2. Using with Other Iterables: While the examples provided use lists, the same approach can be applied to other iterables like sets, tuples, and even dictionaries (though with dictionaries you often evaluate either keys or values).
  3. Nested Conditions: You can also use more complex conditions by incorporating nested comprehensions and other Python constructs.


The all() function stands as a representative of Python’s intuitive design. It offers a convenient way to verify the truthiness of all elements within an iterable, eliminating the need for verbose loops and conditional checks. Whether you’re working with lists, sets, tuples, dictionaries, or strings, the all() function provides consistent, reliable results. By mastering its use, especially in conjunction with conditions and generator expressions, developers can write more concise and efficient code, further harnessing the power and simplicity that Python offers.

Leave a Reply