Given a Matrix, convert it to a list of dictionaries by mapping similar index values.
Input : test_list = [[“Gfg”, [1, 2, 3]], [“best”, [9, 10, 11]]]
Output : [{‘Gfg’: 1, ‘best’: 9}, {‘Gfg’: 2, ‘best’: 10}, {‘Gfg’: 3, ‘best’: 11}]Input : test_list = [[“Gfg”, [1, 2, 3]]]
Output : [{‘Gfg’: 1}, {‘Gfg’: 2}, {‘Gfg’: 3}]
Method #1: The brute way in which this task can be performed is using a loop. In this, we iterate for all the elements in Matrix, and update dictionaries binding keys to appropriate values in dictionary.
Python3
# initializing listtest_list = [["Gfg", [1, 2, 3]], ["is", [6, 5, 4]], ["best", [9, 10, 11]]]# printing original listprint("The original list : " + str(test_list))# using loop to bind Matrix elements to dictionaryres = []for key, val in test_list: for idx, val in enumerate(val): # append values according to rows structure if len(res) - 1 < idx: res.append({key: val}) else: res[idx].update({key: val})# printing resultprint("Converted dictionary : " + str(res)) |
Output:
The original list : [[‘Gfg’, [1, 2, 3]], [‘is’, [6, 5, 4]], [‘best’, [9, 10, 11]]] Converted dictionary : [{‘Gfg’: 1, ‘is’: 6, ‘best’: 9}, {‘Gfg’: 2, ‘is’: 5, ‘best’: 10}, {‘Gfg’: 3, ‘is’: 4, ‘best’: 11}]
Method #2: Using Zip and Dictionary Comprehension
Step-by-step algorithm:
- Create a list of lists, test_list.
- Use the zip function to combine the inner lists of test_list into tuples.
- Create a list comprehension that extracts only the lists of integers from test_list and store them in a separate list.
- Use another zip function to combine the strings from test_list with the tuples.
- Use a list comprehension and dictionary unpacking to create a dictionary for each tuple of strings and integers.
- Store the dictionaries in a list, res.
- Print the final result.
Below is the implementation of the above approach:
Python3
test_list = [["Gfg", [1, 2, 3]], ["is", [6, 5, 4]], ["best", [9, 10, 11]]]# printing original listprint("The original list : " + str(test_list))# using zip to combine the inner lists into tupleszipped = list(zip(*[lst for _, lst in test_list]))# using list comprehension and dictionary unpacking to create the dictionariesres = [{key: val for key, val in zip([k for k, _ in test_list], tup)} for tup in zipped]# printing resultprint("Converted dictionary : " + str(res)) |
The original list : [['Gfg', [1, 2, 3]], ['is', [6, 5, 4]], ['best', [9, 10, 11]]]
Converted dictionary : [{'Gfg': 1, 'is': 6, 'best': 9}, {'Gfg': 2, 'is': 5, 'best': 10}, {'Gfg': 3, 'is': 4, 'best': 11}]
Time Complexity: O(nm), where n is the number of sub-lists in test_list and m is the length of the longest sub-list.
Auxiliary Space: O(nm), where n is the number of sub-lists in test_list and m is the length of the longest sub-list.
Method #3: Using lambda map dict and zip() inbuilt function
- Define the input list of lists.
- Define a lambda function that takes two arguments, one for the key and the other for the value.
- Use the zip function to combine the sublists into a list of tuples.
- For each tuple in the list of tuples, use the map function to apply the lambda function to the corresponding key and value.
- Use the dict function to convert the resulting list of tuples into a dictionary.
- Combine the dictionaries into a list using the list function.
Python3
# initializing listtest_list = [["Gfg", [1, 2, 3]], ["is", [6, 5, 4]], ["best", [9, 10, 11]]]# printing original listprint("The original list : " + str(test_list))# using zip to combine the inner lists into tupleszipped = list(zip(*[lst for _, lst in test_list]))# using lambda function and zip function to create the dictionariesres = [dict(zip(map(lambda x: x[0], test_list), tup)) for tup in zipped]# printing resultprint("Converted dictionary : " + str(res)) |
The original list : [['Gfg', [1, 2, 3]], ['is', [6, 5, 4]], ['best', [9, 10, 11]]]
Converted dictionary : [{'Gfg': 1, 'is': 6, 'best': 9}, {'Gfg': 2, 'is': 5, 'best': 10}, {'Gfg': 3, 'is': 4, 'best': 11}]
Time Complexity: O(nm), where n is the number of sub-lists in test_list and m is the length of the longest sub-list.
Auxiliary Space: O(nm), where n is the number of sub-lists in test_list and m is the length of the longest sub-list.
