Sorting Python List in Descending Order

Need to sort a list in descending order in Python? This guide provides a detailed look at several methods to achieve this, from using the built-in sort() method and sorted() function with the reverse parameter to custom sorting with the key argument and lambda functions.
By the end of this article, you’ll have a solid understanding of how to sort lists in descending order efficiently and effectively, with plenty of practical examples.

Method 1: Using the sort() Method with reverse=True

The sort() method is a built-in Python list method that sorts the list in-place. By setting the reverse parameter to True, you can sort the list in descending order.

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

In this example, my_list.sort(reverse=True) sorts the my_list directly, modifying it to be in descending order. The print() statement then displays the sorted list.

Method 2: Using the sorted() Function with reverse=True

The sorted() function returns a new sorted list from any iterable. Like the sort() method, it accepts a reverse parameter to control the sorting order.

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list, reverse=True)
print("Original list:", my_list)
print("Sorted list:", sorted_list)

Original list: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
Sorted list: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

Here, sorted(my_list, reverse=True) creates a new list called sorted_list containing the elements of my_list sorted in descending order. The original list remains unchanged.

Method 3: Sorting a List of Strings in Descending Order

Both sort() and sorted() can also be used to sort lists of strings. The sorting is done lexicographically (alphabetical order), and reverse=True will reverse the order.

string_list = ["apple", "banana", "cherry", "date"]
string_list.sort(reverse=True)
print(string_list)

sorted_string_list = sorted(["apple", "banana", "cherry", "date"], reverse=True)
print(sorted_string_list)

['date', 'cherry', 'banana', 'apple']
['date', 'cherry', 'banana', 'apple']

This example shows both the in-place sorting with sort() and creating a new sorted list with sorted() on a list of strings.

Method 4: Sorting a List of Tuples in Descending Order by a Specific Element

When sorting a list of tuples, you often want to sort based on a specific element within the tuple. You can achieve this by using the key parameter with a lambda function.

tuple_list = [(1, 'a'), (3, 'c'), (2, 'b')]
tuple_list.sort(key=lambda x: x[0], reverse=True)
print(tuple_list)

sorted_tuple_list = sorted(tuple_list, key=lambda x: x[0], reverse=True)
print(sorted_tuple_list)

[(3, 'c'), (2, 'b'), (1, 'a')]
[(3, 'c'), (2, 'b'), (1, 'a')]

In this case, key=lambda x: x[0] tells the sort() method and sorted() function to sort based on the first element (index 0) of each tuple. The reverse=True ensures the sorting is in descending order.

Method 5: Sorting a List of Dictionaries in Descending Order by a Specific Key

Similar to tuples, you can sort a list of dictionaries by a specific key using the key parameter and a lambda function.

dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
dict_list.sort(key=lambda x: x['age'], reverse=True)
print(dict_list)

sorted_dict_list = sorted(dict_list, key=lambda x: x['age'], reverse=True)
print(sorted_dict_list)

[{'name': 'Bob', 'age': 30}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 20}]
[{'name': 'Bob', 'age': 30}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 20}]

Here, key=lambda x: x['age'] sorts the list of dictionaries based on the value associated with the ‘age’ key in each dictionary, and reverse=True sorts in descending order.

Method 6: Using operator.itemgetter() for Sorting

The operator.itemgetter() function provides a more efficient way to specify the key for sorting, especially when sorting lists of tuples or dictionaries. It avoids the overhead of lambda functions.

import operator

tuple_list = [(1, 'a'), (3, 'c'), (2, 'b')]
tuple_list.sort(key=operator.itemgetter(0), reverse=True)
print(tuple_list)

dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
dict_list.sort(key=operator.itemgetter('age'), reverse=True)
print(dict_list)

[(3, 'c'), (2, 'b'), (1, 'a')]
[{'name': 'Bob', 'age': 30}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 20}]

In this example, operator.itemgetter(0) is used to sort the list of tuples by the first element, and operator.itemgetter('age') is used to sort the list of dictionaries by the ‘age’ key. Using operator.itemgetter is generally more performant than a lambda function for simple key extractions.

Method 7: Custom Sorting Logic with a Function

For more complex sorting requirements, you can define a custom function and use it as the key. This allows for highly customized sorting behavior.

def custom_sort(item):
  # Example: Sort by the length of the name in descending order
  return len(item['name'])

dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
dict_list.sort(key=custom_sort, reverse=True)
print(dict_list)

sorted_dict_list = sorted(dict_list, key=custom_sort, reverse=True)
print(sorted_dict_list)

[{'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
[{'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]

Here, the custom_sort function is used to determine the sorting key based on the length of the ‘name’ in each dictionary. The list is then sorted in descending order of name length.