# A Beginner’s Guide to Sorting Lists in Python

## Understanding the Basics of Sorting Algorithms in Python

Sorting refers to arranging a collection of items in a specific order. In Python, there are several ways to sort lists, and the choice of sorting algorithm depends on various factors such as the size of the list, the type of data it contains, and the desired sorting order.

Some of the commonly used sorting algorithms in Python include:

- Bubble sort: A simple sorting algorithm that repeatedly compares adjacent elements in the list and swaps them if they are in the wrong order.
- Insertion sort: Another simple algorithm that sorts the list by inserting each element into its proper position in a new list.
- Selection sort: A sorting algorithm that selects the smallest element in the list and swaps it with the first element, then selects the second smallest element and swaps it with the second element, and so on until the list is sorted.
- Quick sort: A divide-and-conquer algorithm that recursively divides the list into two sub-lists and sorts them separately.

Understanding the basics of these sorting algorithms can help you choose the most efficient algorithm for your specific use case. In the next sections, we’ll explore how to implement these algorithms in Python and how to use the built-in sorting functions provided by the language.

## Using the Built-in Sorted() Function in Python

Python provides a built-in function called `sorted()`

that can be used to sort a list of items. The `sorted()`

function takes an iterable (e.g. list, tuple, string, etc.) as an argument and returns a new sorted list without modifying the original list.

Here’s an example of how to use the `sorted()`

function to sort a list of numbers in ascending order:

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

Output:

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

Note that the original `numbers`

list remains unchanged after using the `sorted()`

function.

The `sorted()`

function can also be used to sort lists of strings and other data types. By default, the function sorts the list in ascending order, but you can pass additional parameters to customize the sorting behavior, such as sorting in descending order or using a custom key function for sorting.

Using the built-in `sorted()`

function is one of the easiest and most efficient ways to sort a list in Python.

## Sorting Lists with the Sort() Method

In addition to the `sorted()`

function, Python also provides a built-in method called `sort()`

that can be used to sort a list in place, meaning the original list is modified instead of creating a new sorted list.

Here’s an example of how to use the `sort()`

method to sort a list of numbers in ascending order:

`python````
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print(numbers)
```

Output:

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

Note that the original `numbers`

list is now sorted after using the `sort()`

method.

Like the `sorted()`

function, the `sort()`

method can also be used to sort lists of strings and other data types. By default, the method sorts the list in ascending order, but you can pass additional parameters to customize the sorting behavior, such as sorting in descending order or using a custom key function for sorting.

Using the `sort()`

method is convenient if you don’t need to keep the original order of the list and want to modify it in place. However, if you want to keep the original list intact, it’s better to use the `sorted()`

function instead.

## Sorting Lists in Descending Order

By default, both the `sorted()`

function and the `sort()`

method sort lists in ascending order. However, you can sort a list in descending order by passing the `reverse=True`

parameter.

Here’s an example of how to sort a list of numbers in descending order using the `sorted()`

function:

`python````
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)
```

Output:

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

And here’s an example of how to sort a list of numbers in descending order using the `sort()`

method:

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

Output:

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

Note that passing `reverse=True`

reverses the order of the sorting, so the largest numbers come first in the sorted list.

In addition to sorting numbers in descending order, you can also sort lists of strings and other data types in descending order by passing the `reverse=True`

parameter to the `sorted()`

function or the `sort()`

method.

## Sorting Lists with Custom Sorting Criteria

In addition to sorting lists in ascending or descending order, you can also sort lists with custom sorting criteria based on specific properties of the items in the list.

To achieve this, you can pass a `key`

parameter to the `sorted()`

function or the `sort()`

method, which specifies a function to be called on each item in the list to determine its sort order.

Here’s an example of how to sort a list of strings based on their length:

`python````
fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
sorted_fruits = sorted(fruits, key=len)
print(sorted_fruits)
```

Output:

`css````
['date', 'apple', 'banana', 'cherry', 'elderberry']
```

Note that the `len`

function is passed as the `key`

parameter to the `sorted()`

function, which sorts the `fruits`

list based on the length of each string.

Similarly, you can sort a list of objects based on a specific property by passing a lambda function as the `key`

parameter to the `sorted()`

function or the `sort()`

method. For example, if you have a list of dictionaries representing people with `name`

and `age`

properties, you can sort the list based on their age as follows:

`python````
people = [
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 20},
{'name': 'Charlie', 'age': 30},
{'name': 'Dave', 'age': 22},
]
sorted_people = sorted(people, key=lambda person: person['age'])
print(sorted_people)
```

Output:

`css````
[ {'name': 'Bob', 'age': 20}, {'name': 'Dave', 'age': 22}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 30},]
```

In this example, a lambda function is passed as the `key`

parameter to the `sorted()`

function, which returns the value of the `age`

property for each person in the list. This sorts the `people`

list based on their age in ascending order.

Using custom sorting criteria can be useful when you need to sort lists based on specific properties or conditions.