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

- Introduction to the
`sorted()`

function - Basic Usage of
`sorted()`

- Sorting in Ascending and Descending Order
- Custom Sorting with the
`key`

Parameter - Case-Insensitive Sorting
- Sorting Complex Data Structures
- Advanced Custom Sorting with the
`cmp_to_key`

Function (Python 2) - Stability of Sorting
- 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.