# Difference Between sort() And sorted() In Python

We'll compare the Python's list `sort()` and `sorted()` functions in this article. We'll learn about these functions, such as what they are and how they differ programmatically and syntactically.

Python `sort()` and `sorted()` are used to sort the data in ascending or descending order. Their goals are the same but are used in different conditions.

## sort()

The `sort()` function is connected to the Python list and **by default, sorts the list's contents in ascending order**.

```python
# List of names
data = ['Sachin', 'Yogesh', 'Yashwant', 'Rishu']
print(f'Original Data: {data}')

# Using list.sort() function
data.sort()
# Printing sorted data
print(f'Sorted Data: {data}')

----------
Original Data: ['Sachin', 'Yogesh', 'Yashwant', 'Rishu']
Sorted Data: ['Rishu', 'Sachin', 'Yashwant', 'Yogesh']
```

The code above sorts the names in ascending order within the list `data`. That was the most fundamental use of the list `sort()` function. We'll see more examples where we'll manipulate the function's parameters.

### Syntax

`list.sort(reverse=False, key=None)`

Here

`reverse` - Defaults to `False`. If `reverse=True`, the data will be sorted in **descending order**.

`key` - Defaults to `None`. We can specify a **user-defined function** to customize the sorting.

### Examples

We'll play around with these parameters and try with data having different data types to get a better understanding of this function.

**Example 1 - List having different characters**

```python
# Original List
typ_data = ['$', '45', '3j+5', 'Hello']
print(f'Original Data: {typ_data}')

# Sorting the list
typ_data.sort()
# Printing sorted list
print(f'Sorted Data: {typ_data}')

----------
Original Data: ['$', '45', '3j+5', 'Hello']
Sorted Data: ['$', '3j+5', '45', 'Hello']
```

**Example 2 - List containing the different data types**

In the following example, `data` is a list that contains **tuples** and we sorted the `data` in descending order.

```python
# List containing tuple data
data = [
    ('Hey', 'There'),
    ('Geeks', 'Welcome'),
    ('To', 'GeekPython')
]
# Printing the type of list item
print(f'Type: {type(data[0])}')
# Sorting the data in descending order
data.sort(reverse=True)
# Printing modified data
print(data)

----------
Type: <class 'tuple'>
Sorted Data: [('To', 'GeekPython'), ('Hey', 'There'), ('Geeks', 'Welcome')]
```

**What if we specify a similar name for the first values of the tuple?**

```python
# List containing tuple data with first values having similar name
data = [
    ('item', 2),
    ('item', 1),
    ('item', 3)
]
# Printing the type of list item
print(f'Type: {type(data[0])}')
# Sorting the data in descending order
data.sort(reverse=True)
# Printing modified data
print(f'Sorted Data: {data}')

----------
Type: <class 'tuple'>
Sorted Data: [('item', 3), ('item', 2), ('item', 1)]
```

The tuples were sorted based on the second value because `sort()` cannot perform sorting on similar values, or more specifically, how can data be sorted in ascending or descending order if they are all similar?

**Example 3 - Using a user-defined function**

```python
# List containing dictionary data
data = [
    {'fruit': 'strawberry', 'price': 100},
    {'fruit': 'banana', 'price': 91},
    {'fruit': 'mango', 'price': 132},
    {'fruit': 'cherry', 'price': 82},
]

print(f'Original Data: {data}')

# Function for sorting by key 'price'
def sort_dict_by_price(item):
    return item['price']

# Sorting data using the user-defined sorting function
data.sort(key=sort_dict_by_price)
print('-'*20)
# Printing the data
print(f'Sorted Data: {data}')
```

We've written a function called `sort_dict_by_price` that takes a parameter `item`, which is our dictionary itself, and returns the values of the key `'price'`.

This function was passed to the `key` parameter, which will sort the `data` based on the `price` in ascending order.

**Output**

```bash
Original Data: [{'fruit': 'strawberry', 'price': 100}, {'fruit': 'banana', 'price': 91}, {'fruit': 'mango', 'price': 132}, {'fruit': 'cherry', 'price': 82}]
--------------------
Sorted Data: [{'fruit': 'cherry', 'price': 82}, {'fruit': 'banana', 'price': 91}, {'fruit': 'strawberry', 'price': 100}, {'fruit': 'mango', 'price': 132}]
```

**Instead of explicitly defining the** `sort_dict_by_price` **function, we could have used the** `lambda` **function in the above code.**

```python
# List containing dictionary data
data = [
    {'fruit': 'strawberry', 'price': 100},
    {'fruit': 'banana', 'price': 91},
    {'fruit': 'mango', 'price': 132},
    {'fruit': 'cherry', 'price': 82},
]

print(f'Original Data: {data}')

# Sorting data using the lambda function
data.sort(key=lambda item: item['fruit'])
print('-' * 20)
# Printing the data
print(f'Sorted Data: {data}')
```

We changed the code above and passed the `lambda` function to the `key`. The expression `lambda item: item['fruit']` is equivalent to the previous code's `sort_dict_by_price` function.

**Output**

```python
Original Data: [{'fruit': 'strawberry', 'price': 100}, {'fruit': 'banana', 'price': 91}, {'fruit': 'mango', 'price': 132}, {'fruit': 'cherry', 'price': 82}]
--------------------
Sorted Data: [{'fruit': 'banana', 'price': 91}, {'fruit': 'cherry', 'price': 82}, {'fruit': 'mango', 'price': 132}, {'fruit': 'strawberry', 'price': 100}]
```

**Example 4 - Sorting tuple data by specifying sorting criteria**

In the following example, `data` is a list containing tuples and we sorted the `data` in descending order based on the first items of the tuple.

```python
# List containing tuple data
data = [
    ('strawberry', 100),
    ('banana', 91),
    ('mango', 132),
    ('cherry', 82),
]

print(f'Original Data: {data}')

# Sorting data based on first value in descending order
data.sort(key=lambda item: item[0], reverse=True)
print('-' * 20)
# Printing the data
print(f'Sorted Data: {data}')
```

**Output**

```bash
Original Data: [('strawberry', 100), ('banana', 91), ('mango', 132), ('cherry', 82)]
--------------------
Sorted Data: [('strawberry', 100), ('mango', 132), ('cherry', 82), ('banana', 91)]
```

## sorted()

Python `sorted()` function is used to **sort the iterable data**. By default, this function **sorts the data in ascending order**.

```bash
# Tuple data
tuple_data = ((4, 's'), (1, 'q'), (3, 'z'), (4, 'a'))
print(f'Original: {tuple_data}')
# Using sorted function
sorting = sorted(tuple_data)
print('-'*20)
# Printing the sorted data
print(f'Sorted: {sorting}')
```

We have nested tuple data stored in the variable `tuple_data`, used the `sorted()` function with our **iterable** as a parameter, and then printed the sorted data.

**Output**

```bash
Original: ((4, 's'), (1, 'q'), (3, 'z'), (4, 'a'))
--------------------
Sorted: [(1, 'q'), (3, 'z'), (4, 'a'), (4, 's')]
```

The data were sorted based on the **first item** of the tuple `tuple_data`.

### Syntax

`sorted(iterable, key=None, reverse=False)`

Here

`iterable` - Required. Any iterable data

`key` - defaults to `None`. To specify the sorting criteria.

`reverse` - Defaults to `False`. When set to `True`, the data will be sorted in descending order.

### Examples

We have data of various data types that are all iterable; we'll sort them using the `sorted()` function.

```python
list_data = [43, 21, 2, 34]
print(f'Sorted List: {sorted(list_data)}')

# Seperator
print('-'*20)

tuple_data = (('x', 3), ('w', 1), ('1', 4))
print(f'Sorted Tuple: {sorted(tuple_data)}')

# Seperator
print('-'*20)

dict_data = {9: 'G', 1: 'V', 4: 'E'}
print(f'Sorted Dictionary Keys: {sorted(dict_data)}')
print(f'Sorted Dictionary Values: {sorted(dict_data.values())}')
print(f'Sorted Dictionary Items: {sorted(dict_data.items())}')
```

**Output**

```bash
Sorted List: [2, 21, 34, 43]
--------------------
Sorted Tuple: [('1', 4), ('w', 1), ('x', 3)]
--------------------
Sorted Dictionary Keys: [1, 4, 9]
Sorted Dictionary Values: ['E', 'G', 'V']
Sorted Dictionary Items: [(1, 'V'), (4, 'E'), (9, 'G')]
```

**Example 2 - Using** `key` **and** `reverse` **parameters**

```python
# Tuple data
tuple_data = (
    ('Mango', 25),
    ('Walnut', 65),
    ('Cherry', 10),
    ('Apple', 68),
)

print(f'Original: {tuple_data}')
# Separator
print('-'*20)

# Function for grabbing 2nd item from the data
def sorting_tup_data(item):
    return item[1]

# Sorting based on sorting criteria in descending order
sorting = sorted(tuple_data, key=sorting_tup_data, reverse=True)
print(f'Sorted: {sorting}')
```

**Output**

```bash
Original: (('Mango', 25), ('Walnut', 65), ('Cherry', 10), ('Apple', 68))
--------------------
Sorted: [('Apple', 68), ('Walnut', 65), ('Mango', 25), ('Cherry', 10)]
```

Due to the use of the `key` parameter where we passed the custom function, the tuple was sorted based on the **second item** and data was sorted in descending order because the `reverse` was set to `True`.

## Difference

| sort() | sorted() |
| --- | --- |
| Used to sort the Python **List**. | Used to sort any iterable data such as **List**, **Tuple**, **Dictionary,** and more. |
| Takes two parameters: `key` and `reverse`. | Takes three parameters: `iterable`, `key` and `reverse`. |
| It is a `List` function(`list.sort()`) and can only work with Lists. | It is a function to sort any data which can be iterated. |
| `sort()` modifies the original list. | `sorted()` doesn't modify the original data instead it returns the new modified data. |

## Conclusion

We've seen a comparison of the list `sort()` and `sorted()` functions. We've coded the examples to understand how these functions work. Both functions are used to sort data, but the `sort()` function only **sorts Python lists**, whereas the `sorted()` function **sorts iterable data**.

We've also seen the differences between the two in a table format.

---

🏆**Other articles you might be interested in if you liked this one**

✅[Comparing the list reverse and reversed functions](https://geekpython.in/reverse-vs-reversed-in-python).

✅[8 different ways to reverse a Python list](https://geekpython.in/different-ways-to-reverse-a-python-list).

✅[NumPy argmax() and TensorFlow argmax() - Are they similar](https://geekpython.in/argmax-function-in-numpy-and-tensorflow)?

✅[Execute your code dynamically using the exec() in Python](https://geekpython.in/exec-function-in-python).

✅[Perform high-level file operations on files in Python](https://geekpython.in/shutil-module-in-python).

✅[Number your iterable data using the enumerate() in Python](https://geekpython.in/python-enumerate-function-with-example-beginners-guide).

✅[Understanding args and kwargs in function parameter in Python](https://geekpython.in/understanding-args-and-kwargs-in-python-best-practices-and-guide).

---

**That's all for now**

**Keep Coding✌✌**