Python - Sort dictionaries list by Key's Value list index

Given list of dictionaries, sort dictionaries on basis of Key's index value.

Input : [{"Gfg" : [6, 7, 8], "is" : 9, "best" : 10}, {"Gfg" : [2, 0, 3], "is" : 11, "best" : 19}, {"Gfg" : [4, 6, 9], "is" : 16, "best" : 1}], K = "Gfg", idx = 0 
Output : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}] 
Explanation : 2<4<6, hence dictionary ordered in that way by 0th index of Key. 

Input : [{"Gfg" : [6, 7, 8], "is" : 9, "best" : 10}, {"Gfg" : [2, 0, 3], "is" : 11, "best" : 19}, {"Gfg" : [4, 6, 9], "is" : 16, "best" : 1}], K = "Gfg", idx = 1 
Output : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}] 
Explanation : 0<6<7, hence dictionary ordered in that way by 1st index.

Method #1 : Using sorted() + lambda

The combination of above functions can be used to solve this problem. In this, we perform sort using sorted and logic based on list index is provided in lambda function.

Step-by-step approach:

• Define an integer variable called idx and set its value to 2. This is the index of the list that will be used to sort the list.
• Use the sorted() function to sort the test_list in ascending order based on the value of the key K and the value at index idx of the corresponding list. This is done using a lambda function that accesses the K key and the idx index of the corresponding list for each dictionary.
• Store the sorted result in a variable called res.
• Print the result using the print() function and passing the string representation of res.

Below is the implementation of the above approach:

# Python3 code to demonstrate working of 
# Sort dictionaries list by Key's Value list index
# Using sorted() + lambda

# initializing lists
test_list = [{"Gfg" : [6, 7, 8], "is" : 9, "best" : 10}, 
             {"Gfg" : [2, 0, 3], "is" : 11, "best" : 19},
             {"Gfg" : [4, 6, 9], "is" : 16, "best" : 1}]

# printing original list
print("The original list : " + str(test_list))

# initializing K 
K = "Gfg"

# initializing idx 
idx = 2

# using sorted() to perform sort in basis of 1 parameter key and 
# index
res = sorted(test_list, key = lambda ele: ele[K][idx])
    
# printing result 
print("The required sort order : " + str(res))

The original list : [{'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]
The required sort order : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]

Time complexity: O(n log n), where n is the length of the input list of dictionaries.
Auxiliary space: O(1)

Method #2 : Using sorted() + lambda (Additional parameter in case of tie)

STEP BY STEP ALGORITHM:

1. Start by initializing the list of dictionaries test_list with some key-value pairs. Each dictionary has a key Gfg with a list of integers as its value, a key is with an integer as its value, and a key best with an integer as its value.
2. Initialize the variable K with the string "Gfg". This variable will be used to access the list of integers in the value of the Gfg key.
3. Initialize the variable idx with the integer value 2. This variable will be used to access the value of the list at the index 2 of the Gfg key.
4. Initialize the variable K2 with the string "best". This variable will be used to sort the list of dictionaries based on the value of the best key.
5. Use the sorted() function with two key parameters to sort the list of dictionaries in test_list based on the values of the Gfg key's list at index idx and the best key, respectively. The inner key parameter is evaluated after the outer key parameter in the lambda order.
6. Assign the sorted list of dictionaries to the variable res.
7. Print the sorted list of dictionaries.

This is modification in sorting of values, adding another parameter in case of tie of values among list.

# Python3 code to demonstrate working of
# Sort dictionaries list by Key's Value list index
# Using sorted() + lambda (Additional parameter in case of tie)

# initializing lists
test_list = [{"Gfg": [6, 7, 9], "is": 9, "best": 10},
             {"Gfg": [2, 0, 3], "is": 11, "best": 19},
             {"Gfg": [4, 6, 9], "is": 16, "best": 1}]

# printing original list
print("The original list : " + str(test_list))

# initializing K
K = "Gfg"

# initializing idx
idx = 2

# initializing K2
K2 = "best"

# using sorted() to perform sort in basis of 2 parameter key
# inner is evaluated after the outer key in lambda order
res = sorted(
    sorted(test_list, key=lambda ele: ele[K2]), key=lambda ele: ele[K][idx])

# printing result
print("The required sort order : " + str(res))

The original list : [{'Gfg': [6, 7, 9], 'is': 9, 'best': 10}, {'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]
The required sort order : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}, {'Gfg': [6, 7, 9], 'is': 9, 'best': 10}]

Time Complexity: O(n*logn)
Auxiliary Space: O(1)

Method #3: Using itemgetter from operator module

The operator module provides a function called "itemgetter" which can be used to get an item from a list or a dictionary by index. We can use itemgetter to sort the list of dictionaries based on the value at a particular index of a particular key.

from operator import itemgetter

# initializing lists
test_list = [{"Gfg" : [6, 7, 8], "is" : 9, "best" : 10}, 
             {"Gfg" : [2, 0, 3], "is" : 11, "best" : 19},
             {"Gfg" : [4, 6, 9], "is" : 16, "best" : 1}]

# initializing K 
K = "Gfg"

# initializing idx 
idx = 2

# using sorted() with itemgetter() to perform sort in basis of 1 parameter key and index
res = sorted(test_list, key=lambda x: (x[K][idx]))

# printing result 
print("The required sort order : " + str(res))

The required sort order : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]

Time Complexity: O(n*logn), where n is the length of the input list. This is because we're using the built-in sorted() function which has a time complexity of O(nlogn) in the worst case.
Auxiliary Space: O(1), as we're not using any additional space other than the input list itself. 

Method #4: Using a list comprehension and the built-in sorted() function

This program sorts a list of dictionaries based on the value at a specific index of a specific key's value list. It uses a list comprehension and the built-in sorted() function to achieve this. The program prints the original list and the sorted list.

1-A list of dictionaries test_list is initialized with each dictionary containing the key "Gfg" and its corresponding value as a list of integers.

2-The original list test_list is printed using the print() function.

3-The variable K is initialized with the string "Gfg". This variable is used to access the value of the key "Gfg" in each dictionary.

4-The variable idx is initialized with the integer value 2. This variable is used to access the third element of the list corresponding to the key "Gfg".

5-A new list res is created using a list comprehension that sorts the list of dictionaries test_list based on the value at index idx of the value list corresponding to the key K. This is achieved by using the sorted() function with a key parameter that takes a lambda function that returns the value at index idx of the value list corresponding to the key K. The resulting list is assigned to the variable res.

6-The sorted list res is printed using the print() function.

# Python3 code to demonstrate working of
# Sort dictionaries list by Key's Value list index
# Using a list comprehension and the built-in sorted() function

# initializing lists
test_list = [{"Gfg": [6, 7, 8], "is": 9, "best": 10},
             {"Gfg": [2, 0, 3], "is": 11, "best": 19},
             {"Gfg": [4, 6, 9], "is": 16, "best": 1}]

# printing original list
print("The original list : " + str(test_list))

# initializing K
K = "Gfg"

# initializing idx
idx = 2

# using a list comprehension and the built-in sorted() function
res = [d for d in sorted(test_list, key=lambda x: x[K][idx])]

# printing result
print("The required sort order : " + str(res))

The original list : [{'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]
The required sort order : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]

Time complexity: O(n log n), where n is the length of the input list test_list. 
Auxiliary space: O(n), where n is the length of the input list test_list. 

Method #5: Using a loop to append empty dictionaries to the list

Use operator.itemgetter() instead of a lambda function to extract the value of the key from the dictionary. operator.itemgetter() is a function that returns a callable object that fetches the item from its operand using the operand as a key. We can use itemgetter() to get the value associated with the key in the dictionary and then apply the index on the value list to sort the dictionaries in the list.

import operator

# initializing lists
test_list = [{"Gfg": [6, 7, 8], "is": 9, "best": 10},
             {"Gfg": [2, 0, 3], "is": 11, "best": 19},
             {"Gfg": [4, 6, 9], "is": 16, "best": 1}]

# printing original list
print("The original list : " + str(test_list))

# initializing K
K = "Gfg"

# initializing idx
idx = 2

# using sorted() to perform sort in basis of 1 parameter key and
# index
res = sorted(test_list, key=operator.itemgetter(K, idx))

# printing result
print("The required sort order : " + str(res))

OUTPUT-
The original list : [{'Gfg': 3, 4: 9}, {'is': 8, 'Good': 2}, {'Best': 10, 'CS': 1}]
The constructed dictionary : {0: {'Gfg': 3, 4: 9}, 1: {'
is': 8, 'Good': 2}, 2: {'Best': 10, 'CS': 1}}

Time complexity: O(n log n), which is the same as the built-in sorted() function with a lambda function as the key. 
Auxiliary space: O(n), which is the same as the built-in sorted() function with a lambda function as the key. 

Method 6: Using heapq.nsmallest()

Ue the heapq.nsmallest() function. This function returns the smallest n elements from the iterable in a sorted order. We can use this function to return the required sort order by specifying the key parameter to sort on the specified index of the key.

step-by-step approach for the program:

Step 1: Import the "heapq" module.

Step 2: Initialize a list called "test_list" with three dictionaries. Each dictionary contains a key "Gfg" with a list of three integers and two other keys "is" and "best" with corresponding values.

Step 3: Initialize a variable "K" with the string "Gfg". This variable will be used to specify the key for sorting the dictionaries.

Step 4: Initialize a variable "idx" with the integer 2. This variable will be used to specify the index of the element in the list corresponding to the key "Gfg" that will be used for sorting the dictionaries.

Step 5: Use the "heapq.nsmallest()" function to get the required sort order of the dictionaries in the "test_list". The function takes three arguments: the number of items to return, the list to sort, and the key function that returns the value to sort by. In this case, we want to sort by the element at index "idx" of the list corresponding to the key "Gfg", so we use a lambda function to specify that.

Step 6: Store the result in a variable called "res".

Step 7: Print the required sort order.

import heapq

# initializing lists
test_list = [{"Gfg": [6, 7, 8], "is": 9, "best": 10},
             {"Gfg": [2, 0, 3], "is": 11, "best": 19},
             {"Gfg": [4, 6, 9], "is": 16, "best": 1}]

# initializing K
K = "Gfg"

# initializing idx
idx = 2

# using heapq.nsmallest() to get the required sort order
res = heapq.nsmallest(len(test_list), test_list, key=lambda x: x[K][idx])

# printing result
print("The required sort order : " + str(res))

The required sort order : [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]

The time complexity of heapq.nsmallest() is O(n log k), where n is the length of the input list and k is the number of smallest elements to be returned. In this case, k is equal to the length of the input list, so the time complexity is O(n log n).

The space complexity of heapq.nsmallest() is O(k), where k is the number of smallest elements to be returned. In this case, k is equal to the length of the input list, so the space complexity is O(n).

Method #7: Using functools.cmp_to_key() and custom comparison function

Here's an implementation using the functools.cmp_to_key() function along with a custom comparison function. This approach allows for more complex sorting criteria beyond just the index of a single key's value list.

1. First, the program defines a function called compare_dicts_by_key_index, which takes in three arguments:
2. d1: A dictionary
   d2: A dictionary
   key: A string representing the key in the dictionaries to compare
   idx: An integer representing the index of the value in the list associated with the key to compare
   The function compare_dicts_by_key_index compares the values at the specified index (idx) in the lists associated with the specified key (key) for the two input dictionaries (d1 and d2). If the value in d1 is less than the value in d2, the function returns -1. If the value in d1 is greater than the value in d2, the function returns 1. Otherwise, the function proceeds to compare the "is" key in descending order. If d1["is"] is greater than d2["is"], the function returns -1. If d1["is"] is less than d2["is"], the function returns 1. If the values at the "is" key are equal, the function returns 0.
3. Next, the program initializes a list of dictionaries called test_list, containing three dictionaries. Each dictionary contains a key "Gfg" with a list of three integers associated with it, as well as two other keys "is" and "best" with integer values associated with them.
4. The program initializes two variables: K, which is set to "Gfg", and idx, which is set to 2.
5. The program then sorts the test_list using sorted() function with the key argument set to functools.cmp_to_key(lambda d1, d2: compare_dicts_by_key_index(d1, d2, K, idx)). Here, the cmp_to_key() function converts the compare_dicts_by_key_index function into a key function that can be used by the sorted() function. 

import functools


def compare_dicts_by_key_index(d1, d2, key, idx):
    if d1[key][idx] < d2[key][idx]:
        return -1
    elif d1[key][idx] > d2[key][idx]:
        return 1
    else:
        # if the values at the given index are equal,
        # sort by the "is" key in descending order
        if d1["is"] > d2["is"]:
            return -1
        elif d1["is"] < d2["is"]:
            return 1
        else:
            return 0


# initializing lists
test_list = [
    {"Gfg": [6, 7, 8], "is": 9, "best": 10},
    {"Gfg": [2, 0, 3], "is": 11, "best": 19},
    {"Gfg": [4, 6, 9], "is": 16, "best": 1}
]

# initializing K and idx
K = "Gfg"
idx = 2

# sorting the list using functools.cmp_to_key() and compare_dicts_by_key_index()
res = sorted(test_list, key=functools.cmp_to_key(
    lambda d1, d2: compare_dicts_by_key_index(d1, d2, K, idx)))

# printing result
print("The required sort order: " + str(res))

The required sort order: [{'Gfg': [2, 0, 3], 'is': 11, 'best': 19}, {'Gfg': [6, 7, 8], 'is': 9, 'best': 10}, {'Gfg': [4, 6, 9], 'is': 16, 'best': 1}]

Time complexity: O(n log n)
Auxiliary space: O(1)