How To Use the all, any, max, and min Functions in Python

The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

Introduction

Python includes a number of built-in functions—these are global Python functions that can be called from any Python code without importing additional modules. For example, you can always call the print built-in function to output text.

Several of the built-in functions (all, any, max, and min among them) take iterables of values as their argument and return a single value. An iterable is a Python object that can be “iterated over”, that is, it will return items in a sequence such that you can use it in a for loop. Built-in functions are useful when, for example, you want to determine if all or any of the elements in a list meet a certain criteria, or find the largest or smallest element in a list.

In this tutorial, you will use the built-in functions all, any, max, and min.

Prerequisites

To get the most out of this tutorial, it is recommended to have:

• Some familiarity with programming in Python 3. You can review our How To Code in Python 3 tutorial series for background knowledge.

• The Python Interactive Console, if you would like to try out the example code in this tutorial you can use the How To Work with the Python Interactive Console tutorial.

Using all

The built-in function all checks if every element in an iterable is True. For example:

all([True, True])

If you run the previous code, you will receive this output:

Output
True

In this first example, you call all and give it a list with two elements (two True Boolean values). Since every element in the iterable is True, the output was True.

all will return False if one or more elements in the given iterable is False:

all([True, False, True])

If you run the previous code, you’ll receive this output:

Output
False

You call all with a list containing three elements including one False Boolean value. Since one of the elements in the iterable was False, the output of the call to all was False.

Notably, all stops iterating and immediately returns False as soon as it encounters the first False entry in an iterable. So, all can be useful if you want to check successive conditions that may build on each other, but return immediately as soon as one condition is False.

A special case to be aware of is when all is given an empty iterable:

all([])

If you run the previous code, you’ll receive this output:

Output
True

When you give all an empty iterable (for example, an empty list like all([])), its return value is True. So, all returns True if every element in the iterable is True or there are 0 elements.

all is particularly helpful when combined with generators and custom conditions. Using all is often shorter and more concise than if you were to write a full-fledged for loop. Let’s consider an example to find out whether there are elements in a list that start with "s":

animals = ["shark", "seal", "sea urchin"]
all(a.startswith("s") for a in animals)

If you run the previous code, you will receive this output:

Output
True

You call all with a generator as its argument. The generator produces a Boolean for each element in the animals list based on whether or not the animal starts with the letter s. The final return value is True because every element in the animals list starts with s.

Note: You can often use Generator expressions in place of list comprehensions as a way of saving memory. For example, consider all(i < 8 for i in range(3)) and all([i < 8 for i in range(3)]). Both statements return True because 0, 1, 2 are all less than 8. The second example (which uses a list comprehension), however, has the added overhead of implicitly creating a list three entries long ([True, True, True]) and then passing that list to the all function. The first example (which uses generator expressions), by contrast, passes a generator object to the all function, which the all function iterates over directly without the overhead of an intermediary list.

Consider that the equivalent code written using a full-fledged for loop would have been significantly more verbose:

animals = ["shark", "seal", "sea urchin"]

def all_animals_start_with_s(animals):
    for a in animals:
        if not a.startswith("s"):
            return False
    return True

print(all_animals_start_with_s(animals))

Without all, your code for determining if all the animals start with the letter s requires several more lines to implement.

Next, you’ll look at the sibling function to all: any.

Using any

You can use the built-in function any to check if any element in an iterable is True. For example:

any([False, True])

If you run the previous code, you’ll receive this output:

Output
True

You call any and give it a list with two elements (a False Boolean value and a True Boolean value). Since one or more element in the iterable was True, the output was also True.

any will return False if, and only if, 0 of the elements in the given iterable are True:

all([False, False, False])

If you run the previous code, you’ll receive this output:

Output
False

You call any with a list containing three elements (all False Boolean values). Since 0 of the elements in the iterable is True, the output of the call to any is False.

Notably, any stops iterating and immediately returns True as soon as it encounters the first True entry in an iterable. So, any can be useful if you want to check successive conditions, but return immediately as soon as one condition is True.

any—like its sibling method all—is particularly helpful when combined with generators and custom conditions (in place of a full for loop). Let’s consider an example to find out whether there are elements in a list that end with "urchin":

animals = ["shark", "seal", "sea urchin"]
any(s.endswith("urchin") for s in animals)

You will receive this output:

Output
True

You call any with a generator as its argument. The generator produces a Boolean for each element in the animals list based on whether or not the animal ends with urchin. The final return value is True because one element in the animals list ends with urchin.

Note: When any is given an empty iterable (for example, an empty list like any([])), its return value is False. So, any returns False if there are 0 elements in the iterable or all the elements in the iterable are also False.

Next, you’ll review another built-in function: max.

Using max

The built-in function max returns the largest element given in its arguments. For example:

max([0, 8, 3, 1])

max is given a list with four integers as its argument. The return value of max is the largest element in that list: 8.

The output will be the following:

Output
8

If given two or more positional arguments (as opposed to a single positional argument with an iterable), max returns the largest of the given arguments:

max(1, -1, 3)

If you run the previous code, you will receive this output:

Output
3

max is given three individual arguments, the largest of which being 3. So, the return value of the call to max is 3.

Just like any and all, max is particularly helpful because it requires fewer lines to use than equivalent code written as a full for loop.

max can also deal with objects more complex than numbers. For example, you can use max with dictionaries or other custom objects in your program. max can accommodate these objects by using its keyword argument named key.

You can use the key keyword argument to define a custom function that determines the value used in the comparisons to determine the maximum value. For example:

entries = [{"id": 9}, {"id": 17}, {"id": 4}]
max(entries, key=lambda x: x["id"])

The output will be the following:

Output
{'id': 17}

You call max with a list of dictionaries as its input. You give an anonymous lambda function as the key keyword argument. max calls the lambda function for every element in the entries list and returns the value of the "id" key of the given element. The final return value is the second element in entries: {"id": 17}. The second element in entries had the largest "id" value, and so was deemed to be the maximum element.

Note that when max is called with an empty iterable, it refuses to operate and instead raises a ValueError:

max([])

If you run this code, you will receive the following output:

Output
Traceback (most recent call last):
  File "max.py", line 1, in <module>
    max([])
ValueError: max() arg is an empty sequence

You call max with an empty list as its argument. max does not accept this as a valid input, and raises a ValueError Exception instead.

max has a counterpart called min, which you’ll review next.

Using min

The built-in function min returns the smallest element given in its arguments. For example:

min([8, 0, 3, 1])

You give min a list with four integers as its argument. The return value of min is the smallest element in that list: 0.

The output will be:

Output
0

If given two or more positional arguments (as opposed to a single positional argument with an iterable), min returns the smallest of the given arguments:

min(1, -1, 3)

If you run the previous code, you will receive this output:

Output
-1

You give min three individual arguments, the smallest of which being -1. So, the return value of the call to min is -1.

Like max, min supports the keyword argument named key so that you can pass objects more complex than numbers into it. Using the key argument allows you to use the min function with any custom objects your program might define.

You can use the key keyword argument to define a custom function that determines the value used in the comparisons to determine the minimum value. For example:

entries = [{"id": 9}, {"id": 17}, {"id": 4}]
min(entries, key=lambda x: x["id"])

Output
{'id': 4}

You call min with a list of dictionaries as its input. You give an anonymous lambda function as the key keyword argument. min calls the lambda function for every element in the entries list and returns the value of the "id" key of the given element. The final return value is the third element in entries: {"id": 4}. The third element in entries had the smalled "id" value, and so was deemed to be the minimum element.

Like max, when you call min with an empty iterable, it refuses to operate and instead raises a ValueError:

min([])

If you run the previous code, you will receive this output:

Output
Traceback (most recent call last):
  File "min.py", line 1, in <module>
    min([])
ValueError: min() arg is an empty sequence

You call min with an empty list as its argument. min does not accept this as a valid input, and raises a ValueError Exception instead.

Conclusion

In this tutorial, you used the Python built-in functions all, any, max, and min. You can learn more about the functions all, any, max, and min and other Python built-in in the Python docs.

For more information on other Python built-ins, you can also check out Built-in Python 3 Functions for Working with Numbers, How To Use the Python Map Function, and How To Use the Python Filter Function.