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.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 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
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 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?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# 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
|
1 2 3 |
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# 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
|
1 2 3 |
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# 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
|
1 2 3 |
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.
|
1 2 3 4 5 6 7 8 |
# 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
|
1 2 3 |
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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
|
1 2 3 4 5 6 7 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# 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
|
1 2 3 |
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.
✅8 different ways to reverse a Python list.
✅NumPy argmax() and TensorFlow argmax() – Are they similar?
✅Execute your code dynamically using the exec() in Python.
✅Perform high-level file operations on files in Python.
✅Number your iterable data using the enumerate() in Python.
✅Understanding args and kwargs in function parameter in Python.
That’s all for now
Keep Coding✌✌
