5 Best Ways to Find the Largest or Smallest Items in Python

Rate this post

πŸ’‘ Problem Formulation: When working with data in Python, you might often need to find the largest or smallest elements within a collection like a list, a tuple, or a dictionary. For example, given a list of numbers [5, 1, 8, 3], we want to find the largest value (8) or the smallest value (1).

Method 1: Using Built-in min() and max() Functions

Python provides built-in functions min() and max() to easily find the smallest and the largest items in an iterable, respectively. These functions require the iterable as an argument and return a single element, which is the smallest or largest. If multiple elements are equally small or large, the function will return the first one encountered.

Here’s an example:

numbers = [5, 1, 8, 3]
print(min(numbers))  # Smallest
print(max(numbers))  # Largest



This code snippet demonstrates how to find the smallest and largest numbers in a list called numbers by passing it as an argument to the min() and max() functions, respectively.

Method 2: Sorting the List

We can find the largest or smallest item by sorting the list first and then selecting the first or last element, depending on whether we want the smallest or largest. The sorted() function returns a new list and does not modify the original list. Alternatively, the list method sort() can sort the list in place.

Here’s an example:

numbers = [5, 1, 8, 3]
sorted_numbers = sorted(numbers)  # returns a new sorted list
print(sorted_numbers[0])  # Smallest
print(sorted_numbers[-1])  # Largest



First, the list numbers is sorted in ascending order and assigned to sorted_numbers. The smallest item is at index 0, and the largest is at index -1 (the last index).

Method 3: Using a Custom Key Function

Both the min() and max() functions allow for a custom key function that specifies a criterion for comparison. This is useful when dealing with a list of non-numeric values or more complex data types, such as tuples or dictionaries.

Here’s an example:

pets = [('cat', 4), ('dog', 7), ('parrot', 2)]
# Find the pet with the least age
youngest_pet = min(pets, key=lambda pet: pet[1])


('parrot', 2)

The min() function is used with a key function that returns the second item of each tuple (pet[1]) which represents the age. Thus, it finds the tuple with the smallest second item, indicating the youngest pet.

Method 4: Using Heapq Module

The heapq module provides a way to always have the smallest or largest value readily available. The heapq.nsmallest() and heapq.nlargest() functions can find a specified number of smallest or largest elements, while maintaining the heap property.

Here’s an example:

import heapq
numbers = [5, 1, 8, 3]
print(heapq.nsmallest(1, numbers))  # Smallest
print(heapq.nlargest(1, numbers))  # Largest



The heapq.nsmallest() and heapq.nlargest() functions are used to get the list with the single smallest and largest elements, respectively. Note that the output is a list, hence the square brackets around the numbers.

Bonus One-Liner Method 5: Using List Comprehension and ternary operator

A compact way of achieving this that’s not commonly recommended due to readability concerns is by using list comprehension and ternary conditional operators.

Here’s an example:

numbers = [5, 1, 8, 3]
smallest = [num for num in numbers if num = max(numbers)]
print(smallest, largest)


[1] [8]

This code snippet uses list comprehension to iterate through each number and check if it’s less than or equal to the smallest number found with min() or greater than or equal to the largest number found with max(), respectively.


  • Method 1: Built-in Functions. Straightforward and efficient for most use-cases. Not suitable when custom comparison criteria are involved.
  • Method 2: Sorting. Universal application but less efficient for large datasets because it sorts the entire list. Better to use when the sorted list is needed for other operations as well.
  • Method 3: Custom Key Function. Flexible for complex data structures or custom sorting criteria. It can be slower for simple cases where the default comparison is sufficient.
  • Method 4: Heapq Module. Highly efficient for continuously finding smallest/largest elements in a changing dataset, such as real-time data. Overkill for static, small datasets.
  • Bonus Method 5: List Comprehension and Ternary Operator. Quick one-liners but can be confusing at a glance. It also lacks efficiency by calling min() or max() for each element.