Python sorted() Function: Understanding Sorting Lists and More (With Examples)

Sorting is a fundamental operation in programming, allowing us to arrange elements in a particular order for easier manipulation, searching, and analysis. In Python, the sorted() function plays a vital role in accomplishing this task. In this tutorial, we will delve deep into the workings of the sorted() function, explore its various applications, and provide comprehensive examples to help you grasp its usage effectively.

Table of Contents

1. Introduction to the sorted() function
2. Basic Usage of sorted()
3. Sorting in Ascending and Descending Order
4. Custom Sorting with the key Parameter
5. Case-Insensitive Sorting
6. Sorting Complex Data Structures
7. Advanced Custom Sorting with the cmp_to_key Function (Python 2)
8. Stability of Sorting
9. Conclusion

1. Introduction to the sorted() function

The sorted() function in Python is used to sort an iterable (such as a list, tuple, or string) into a new sorted list. It returns a new list containing all elements from the original iterable arranged in ascending order by default. The sorted() function does not modify the original iterable; instead, it creates a new sorted list.

2. Basic Usage of sorted()

Let’s start with a simple example of using the sorted() function:

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)

print("Original list:", numbers)
print("Sorted list:", sorted_numbers)

Output:

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

In this example, the sorted() function takes the numbers list as input, sorts its elements in ascending order, and returns a new list sorted_numbers.

3. Sorting in Ascending and Descending Order

The default behavior of the sorted() function is to sort elements in ascending order. However, you can also sort elements in descending order by using the reverse parameter.

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
ascending_sorted = sorted(fruits)
descending_sorted = sorted(fruits, reverse=True)

print("Ascending order:", ascending_sorted)
print("Descending order:", descending_sorted)

Output:

Ascending order: ['apple', 'banana', 'cherry', 'date', 'elderberry']
Descending order: ['elderberry', 'date', 'cherry', 'banana', 'apple']

4. Custom Sorting with the key Parameter

The key parameter of the sorted() function allows you to define a custom sorting criterion. This criterion is applied to each element before sorting, which allows you to sort elements based on a specific attribute or calculation.

Suppose we have a list of words, and we want to sort them based on their lengths:

words = ["apple", "banana", "cherry", "date", "elderberry"]
sorted_by_length = sorted(words, key=len)

print("Sorted by length:", sorted_by_length)

Output:

Sorted by length: ['date', 'apple', 'banana', 'cherry', 'elderberry']

In this example, the key=len argument tells the sorted() function to sort the words based on their lengths.

5. Case-Insensitive Sorting

Sorting strings with mixed cases can sometimes lead to unexpected results. However, you can perform case-insensitive sorting using the key parameter in combination with the str.lower() method.

animals = ["Lion", "elephant", "Tiger", "giraffe", "zebra"]
case_insensitive_sorted = sorted(animals, key=str.lower)

print("Case-insensitive sorted:", case_insensitive_sorted)

Output:

Case-insensitive sorted: ['elephant', 'giraffe', 'Lion', 'Tiger', 'zebra']

The key=str.lower argument converts all elements to lowercase before sorting, ensuring case-insensitive ordering.

6. Sorting Complex Data Structures

The sorted() function is not limited to sorting simple lists of numbers or strings; it can also sort more complex data structures. Let’s consider an example where we have a list of dictionaries, and we want to sort them based on a specific dictionary key:

people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Eve", "age": 28}
]

sorted_by_age = sorted(people, key=lambda person: person["age"])

print("Sorted by age:", sorted_by_age)

Output:

Sorted by age: [{'name': 'Bob', 'age': 25}, {'name': 'Eve', 'age': 28}, {'name': 'Alice', 'age': 30}]

In this example, the key=lambda person: person["age"] argument specifies that the sorting should be based on the “age” key of each dictionary.

7. Advanced Custom Sorting with the cmp_to_key Function (Python 2)

Note: The cmp_to_key function is specific to Python 2 and is provided here for reference. It’s not available in Python 3.

In Python 2, you can use the cmp_to_key() function from the functools module to achieve more advanced custom sorting. This function converts a comparison function that takes two arguments into a key function that can be used with the sorted() function.

Here’s an example that demonstrates sorting based on a custom comparison function using cmp_to_key:

from functools import cmp_to_key

def custom_compare(a, b):
    if len(a) < len(b):
        return -1
    elif len(a) > len(b):
        return 1
    else:
        return 0

words = ["apple", "banana", "cherry", "date", "elderberry"]
sorted_custom = sorted(words, key=cmp_to_key(custom_compare))

print("Sorted using custom comparison:", sorted_custom)

Output:

Sorted using custom comparison: ['date', 'apple', 'cherry', 'banana', 'elderberry']

In this example, the custom_compare function defines a custom comparison rule, and cmp_to_key(custom_compare) converts it into a key function for sorting.

8. Stability of Sorting

Python’s sorted() function is guaranteed to be stable, which means that the relative order of elements that compare equal will be preserved in the sorted output. This property is essential when you need to sort based on multiple criteria.

Consider the following example:

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

students = [
    Student("Alice

", 85),
    Student("Bob", 90),
    Student("Eve", 85),
]

sorted_students = sorted(students, key=lambda student: student.score)

print("Sorted students:", [student.name for student in sorted_students])

Output:

Sorted students: ['Alice', 'Eve', 'Bob']

In this example, two students have the same score. Thanks to the stability of sorting, the original order is preserved for students with equal scores.

9. Conclusion

The sorted() function is a versatile tool in Python that empowers you to arrange elements in various ways according to your needs. By understanding its usage and various parameters like key and reverse, you can efficiently sort lists and other iterables based on different criteria. Whether you’re sorting simple lists or complex data structures, the sorted() function offers a powerful solution for all your sorting requirements.