Skip to main content

How to Check If a List Is Sorted in Descending Order in Python

Checking the order of elements in a list is a common validation step in data processing and algorithm design. A list is considered sorted in descending order if every element is greater than or equal to the element that follows it (e.g., [5, 4, 3, 2, 1]).

This guide explores three methods to verify descending order: the readable approach using sorted(), the efficient iterative approach, and the concise all() function.

Understanding Descending Order​

Descending order means items are arranged from largest to smallest.

  • Numbers: [10, 8, 5, 2]
  • Strings: ['zebra', 'world', 'apple'] (Lexicographical order)

Python provides tools to sort lists easily, but checking if a list is already sorted requires a comparison logic.

Method 1: Comparison with a Sorted Copy (Readable)​

The simplest way to check for descending order is to sort a copy of the list in reverse and compare it to the original. If they are identical, the original was already sorted.

Using sorted(reverse=True)​

numbers = [9, 7, 5, 3, 1]

# ⛔️ Incorrect: .sort() modifies the list in-place and returns None
# if numbers == numbers.sort(reverse=True):
#     print("This won't work because comparison is against None")

# ✅ Correct: sorted() creates a NEW list for comparison
is_descending = numbers == sorted(numbers, reverse=True)

print(f"Original: {numbers}")
print(f"Is descending? {is_descending}")

Output:

Original: [9, 7, 5, 3, 1]
Is descending? True
note

This method creates a full copy of the list, meaning it uses O(N) extra memory. For small to medium lists, this is fine, but for massive datasets, it may be inefficient.

Method 2: Iterative Approach (Memory Efficient)​

For optimal performance with large lists, you should iterate through the list and check neighbors. If you find any element that is smaller than the next element (list[i] < list[i+1]), the list is not descending.

This method uses O(1) memory and can stop execution early (short-circuit) as soon as it finds an unsorted pair.

def check_descending_loop(data):
    # Iterate up to the second-to-last element
    for i in range(len(data) - 1):
        # Check if the current element is LESS than the next
        if data[i] < data[i + 1]:
            return False
    return True

list_a = [10, 8, 8, 5]  # Descending (with duplicates)
list_b = [10, 5, 8, 2]  # Unsorted

print(f"List A: {check_descending_loop(list_a)}")
print(f"List B: {check_descending_loop(list_b)}")

Output:

List A: True
List B: False

Method 3: Using all() (Concise)​

Python's all() function allows you to write the iterative logic in a single, readable line using a generator expression. This retains the memory efficiency of the loop method while being more "Pythonic."

data = [100, 50, 25, 10]

# ✅ Correct: Check if every element is >= the next element
is_descending = all(data[i] >= data[i+1] for i in range(len(data)-1))

print(f"Is {data} descending? {is_descending}")

Output:

Is [100, 50, 25, 10] descending? True
tip

For strict descending order (no duplicates allowed), change the operator from >= to >.

Conclusion​

To check if a list is sorted in descending order:

  1. Use lst == sorted(lst, reverse=True) for readability on standard lists.
  2. Use all() or a for loop for memory efficiency on large datasets.
  3. Remember that .sort() sorts in-place and returns None, so it cannot be used directly in an if condition for checking.

Table of Contents