Different ways of sorting Dictionary by Values and Reverse sorting by values

Prerequisite: Dictionaries in Python

A dictionary is a collection which is unordered, changeable, and indexed. In Python, dictionaries are written with curly brackets, and they have keys and values. We can access the values of the dictionary using keys. In this article, 10 different ways of sorting the Python dictionary by values and also reverse sorting by values are discussed.

Using lambda function along with items() and sorted(): The lambda function returns the key(0^th element) for a specific item tuple, When these are passed to the sorted() method, it returns a sorted sequence which is then type-casted into a dictionary. keys() method returns a view object that displays a list of all the keys in the dictionary. sorted() is used to sort the keys of the dictionary.

Examples:

Input: my_dict = {2: ‘three’, 1: ‘two’} 
Output: [(2, ‘three’), (1, ‘two’)] 

Below is the implementation using lambda function:

Sorted dictionary is : [(2, 'three'), (1, 'two')]

The time complexity of this program is O(n log n), where n is the size of the dictionary. 

The space complexity is O(n), where n is the size of the dictionary.

Using items() alone: The method items() is used alone with two variables i.e., key and value to sort the dictionary by value.

Examples:

Input: my_dict = {‘c’: 3, ‘a’: 1, ‘d’: 4, ‘b’: 2}
Output: [(1, ‘a’), (2, ‘b’), (3, ‘c’), (4, ‘d’)] 
 

Below is the implementation using method items():

Sorted dictionary is :
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

Time Complexity: O(n log n)
Space Complexity: O(n)

Using sorted() and get(): The method get() returns the value for the given key, if present in the dictionary. If not, then it will return None.

Examples:

Input: my_dict = {‘red’:’#FF0000′, ‘green’:’#008000′, ‘black’:’#000000′, ‘white’:’#FFFFFF’} 
Output: 
black #000000 
green #008000 
red #FF0000 
white #FFFFFF  

Below is the implementation using sorted() and get() method:

Sorted dictionary is :
black # 000000
green # 008000
red # FF0000
white # FFFFFF

Time complexity: O(nlogn) – sorting the dictionary using the sorted() function takes nlogn time, 

Auxiliary space: O(n) – creating a new list of keys in sorted order takes O(n) space.

Using itemgetter from operator:

The method itemgetter(n) constructs a callable that assumes an iterable object as input, and fetches the n-th element out of it.

Examples

Input: 
my_dict = {‘a’: 23, ‘g’: 67, ‘e’: 12, 45: 90} 
Output: 
[(‘e’, 12), (‘a’, 23), (‘g’, 67), (45, 90)] 
 

Below is the python program to sort the dictionary using itemgetter(): 

Sorted dictionary is :
[('e', 12), ('a', 23), ('g', 67), (45, 90)]

Time complexity: O(n log n)

The time complexity of sorting a dictionary using the itemgetter() function is O(n log n). This is because the itemgetter() function must traverse through the dictionary and compare each element to determine the sorting order. Since comparing each element is an O(n) operation, and sorting is an O(log n) operation, the overall time complexity is O(n log n).

Space complexity: O(n)

The space complexity of sorting a dictionary using the itemgetter() function is O(n). This is because the itemgetter() function must create a new list containing all of the elements of the dictionary, which requires O(n) space.

Using OrderedDict from collections: The OrderedDict is a standard library class, which is located in the collections module. OrderedDict maintains the orders of keys as inserted.

Examples:

Input: my_dict = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} 
Output: [(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]
 

Below is the implementation using Ordered Dict:

Sorted dictionary is :
OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

Time complexity: The time complexity of this program is O(n log n), where n is the size of the dictionary.

Space complexity: The space complexity of this program is O(n), where n is the size of the dictionary.

Using Counter from collections: The counter is an unordered collection where elements are stored as Dict keys and their count as dict value. Counter elements count can be positive, zero or negative integers.

Examples: 

Input: my_dict = {‘hello’: 1, ‘python’: 5, ‘world’: 3}
Output: [(‘hello’, 1), (‘world’, 3), (‘python’, 5)] 
 

Below is the implementation using Counter from collections:

Sorted dictionary is :
[('hello', 1), ('world', 3), ('python', 5)]

Reverse Sorting Dictionary by values: The same syntax for both ascending and descending ordered sorting. For reverse sorting, the idea is to use reverse = true. with the function sorted().

Examples:

Input: 
my_dict = {‘red’:’#FF0000′, 
‘green’:’#008000′, 
‘black’:’#000000′, 
‘white’:’#FFFFFF’} 
Output: 
black #000000 
green #008000 
red #FF0000 
white #FFFFFF 
 

Below is the implementation using Reverse Sorting Dictionary by values:

Sorted dictionary is :
white # FFFFFF
red # FF0000
green # 008000
black # 000000