Python – Sort Dictionary ignoring Key

Sometimes, while working with Python dictionaries, we can have problem in which we need to perform sorting of dictionary elements. This is quite straight forward, but sometimes, we can have certain stray keys, which we don’t wish to alter order while sorting. This works for Python >= 3.6 as keys are ordered in dictionary this version onwards. This can have applications in data domains. Let’s discuss a way in which this task can be performed.

Input : test_dict = {“*-*” : “stray”, 70 : ‘is’} Output : {“*-*” : “stray”, 70 : ‘is’} Input : test_dict = {54 : “gfg”, “*-*” : “stray”, 20 : ‘best’} Output : {20: ‘best’, ‘*-*’: ‘stray’, 54: ‘gfg’}

Method : Using next() + sorted() + insert() The combination of above methods, can be used to solve this problem. In this, we perform sorting using sorted(), insert() is used to insert the stray element at its position and next() is used to get next key in order in case of initial stray key. 

Method#2 : Using lambda+dict

Approach

we use the built-in sorted() function to sort the dictionary by values. We ignore the keys by using a lambda function that returns only the values for comparison. The sorted() function returns a list of tuples, which we can convert back to a dictionary.

Algorithm

1. Create a lambda function that returns only the values from the dictionary.
2. Use the sorted() function with the dictionary and the lambda function as arguments to sort the dictionary by values.
3. Convert the sorted list of tuples back to a dictionary.

{20: 'best', 54: 'gfg', '*-*': 'stray'}

Time Complexity: O(nlogn) – sorting the dictionary takes nlogn time complexity.
Space Complexity: O(n) – creating a list of tuples for the sorted dictionary.

Method#3: using collections.OrderedDict:

1.Import the collections module.
2.Initialize the original dictionary test_dict with some key-value pairs.
3.Create a new dictionary sorted_dict using the collections.OrderedDict constructor and pass to it the sorted list of key-value pairs of the original dictionary based on their values. The sorted() function is used to sort the dictionary items based on the values using the key argument which 4.specifies a lambda function to extract the values of each item in the dictionary.
5.Print the original and sorted dictionaries.

Original Dictionary:
{45: 'is', 12: 'gfg', 100: 'best', '*-*': 'stray', 150: 'neveropen', 120: 'for'}
Sorted Dictionary:
OrderedDict([(100, 'best'), (120, 'for'), (150, 'neveropen'), (12, 'gfg'), (45, 'is'), ('*-*', 'stray')])

The time complexity :O(nlogn), where n is the size of the original dictionary, because sorting the dictionary based on values using sorted() takes O(nlogn) time.

The auxiliary space : O(n) because we are creating a new dictionary with the same number of key-value pairs as the original dictionary.

Method#4: Using operator.itemgetter():

Algorithm:

1.Get the dictionary to be sorted.
2.Use the sorted() function to sort the dictionary by its values using operator.itemgetter() to retrieve the value of each item.
3.Convert the sorted result into a dictionary using the dict() constructor.
4.Iterate over the items in the sorted dictionary and print them in the desired format.

Original Dictionary:
{45: 'is', 12: 'gfg', 100: 'best', '*-*': 'stray', 150: 'neveropen', 120: 'for'}
100: best
120: for
150:neveropen
12: gfg
45: is
*-*: stray

The time complexity :O(n log n), where n is the number of items in the dictionary. This is because the sorted() function used to sort the dictionary has a time complexity of O(n log n).

The Auxiliary space :O(n). This is because the algorithm creates a new list of dictionary items that is n items long to sort the dictionary. It then creates a new dictionary that is n items long to hold the sorted items. Finally, it iterates over the sorted dictionary and prints the items, which takes O(n) space in the worst case. Therefore, the space complexity of the algorithm is O(n).

Method #5: Using the items() method, sorted() method and dictionary comprehension

Algorithm:

1. Define a function named “sort_dict” that takes “test_dict” as input.
2. Sort the dictionary items using the sorted() method with a lambda function as the key.
3. Create a new dictionary with sorted items and return the sorted dictionary.

{20: 'best', 54: 'gfg', '*-*': 'stray'}

Time complexity:  O(n log n) in the worst case where n is the size of the dictionary. Creating a new dictionary takes O(n) time. Therefore, the overall time complexity of the function is O(n log n).

Auxiliary Space: O(n) in the worst case where n is the size of the dictionary depending on the size of the input dictionary. The sorted_items list takes O(n) space, and the sorted dictionary takes O(n) space.