# Convert Dictionary Value list to Dictionary List Python

Sometimes, while working with Python Dictionaries, we can have a problem in which we need to convert dictionary list to nested records dictionary taking each index of dictionary list value and flattening it. This kind of problem can have application in many domains.

Let’s discuss certain ways in which this task can be performed.

Input : test_list = [{‘Gfg’: [5, 6]}, {‘best’: [3, 1]}]
Output : [{‘Gfg’: 5, ‘best’: 3}, {‘Gfg’: 6, ‘best’: 1}]

Input : test_list = [{‘Gfg’: }]
Output : [{‘Gfg’: 5}]

### Convert Dictionary Value list to Dictionary Using loop

This is one of the ways in which this problem can be solved. In this, we perform the task in brute force manner iterating each list value index and designating a key to it.

Step-by-step approach:

• Create an empty list res that will hold the converted dictionaries.
• Initialize idx to 0. This variable will be used to track the index of the current dictionary in res.
• Loop through each dictionary in test_list.
• For each dictionary in test_list, loop through each key-value pair using the items() method.
• For each value in the current key-value pair, loop through the elements of the list using a for loop.
• For each element in the list, assign a new dictionary to res[idx] where the key is the current key and the value is the current element.
• Increment the idx variable to move on to the next dictionary in res.
• Reset idx to 0, since we only want one key-value pair in each dictionary in res.
• Print the converted list using the print() function.

Below is the implementation of the above approach:

## Python3

 `# Python3 code to demonstrate working of ` `# Convert Dictionary Value list to Dictionary List` `# Using loop`   `# initializing list` `test_list ``=` `[{``'Gfg'` `: [``5``, ``6``, ``5``]}, {``'is'` `: [``10``, ``2``, ``3``]}, {``'best'` `: [``4``, ``3``, ``1``]}] `   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# Convert Dictionary Value list to Dictionary List` `# Using loop` `res ``=``[{} ``for` `idx ``in` `range``(``len``(test_list))]` `idx ``=` `0` `for` `sub ``in` `test_list:` `    ``for` `key, val ``in` `sub.items(): ` `        ``for` `ele ``in` `val:` `            ``res[idx][key] ``=` `ele` `            ``idx ``+``=` `1` `        ``idx ``=` `0` `        `  `# printing result ` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'best': 1}]```

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

### Convert Dictionary Value list to Dictionary Using list comprehension + zip()

This is yet another way in which we can perform this task. In this, we perform task in 2 steps, first, we extract all the keys and then pair up values using zip() accordingly.

## Python3

 `# Python3 code to demonstrate working of ` `# Convert Dictionary Value list to Dictionary List` `# Using list comprehension + zip()`   `# initializing list` `test_list ``=` `[{``'Gfg'` `: [``5``, ``6``, ``5``]}, ` `             ``{``'is'` `: [``10``, ``2``, ``3``]}, ` `             ``{``'best'` `: [``4``, ``3``, ``1``]}] `   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# Convert Dictionary Value list to Dictionary List` `# Using list comprehension + zip()` `keys ``=` `[``list``(sub.keys())[``0``] ``for` `sub ``in` `test_list]` `vals ``=` `zip``(``*``[val ``for` `sub ``in` `test_list ``for` `val ``in` `sub.values()])` `res ``=` `[``dict``(``zip``(keys, val)) ``for` `val ``in` `vals]`   `# printing result ` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'b...```

Time complexity: O(nm), where n is the length of the original list and m is the length of the value list in each dictionary.
Auxiliary space: O(nm).

### Convert Dictionary Value list to Dictionary Using loop + enumerate()

Use a loop to iterate over the original list of dictionaries and extract the key-value pairs from each dictionary. It then assigns each value to the corresponding dictionary in the result list.

step-by-step approach of the program:

1. Initialize a list test_list with three dictionaries, where each dictionary has a single key-value pair.
2. Print the original list using the print() function and string concatenation with str().
3. Initialize a list res with empty dictionaries, where the number of dictionaries is equal to the length of test_list.
4. Iterate over the test_list using a for loop with the enumerate() function. For each dictionary d in test_list:
Get the key-value pair of the dictionary as a list of tuples using the items() method, then get the first tuple in the list using indexing .
Assign the key to the variable key and the value to the variable val.
Iterate over the values in val using another for loop with the enumerate() function. For each value v in val:
Assign the value of v to the corresponding key in res using indexing.
5. Print the result using the print() function and string concatenation with str().

## Python3

 `# initializing list` `test_list ``=` `[{``'Gfg'` `: [``5``, ``6``, ``5``]}, {``'is'` `: [``10``, ``2``, ``3``]}, {``'best'` `: [``4``, ``3``, ``1``]}]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# Convert Dictionary Value list to Dictionary List` `# Using loop` `res ``=` `[{} ``for` `i ``in` `range``(``len``(test_list))]` `for` `i, d ``in` `enumerate``(test_list):` `    ``key, val ``=` `list``(d.items())[``0``]` `    ``for` `j, v ``in` `enumerate``(val):` `        ``res[j][key] ``=` `v`   `# printing result` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'best': 1}]```

Time complexity: O(n*m), where n is the length of the original list and m is the length of the value list in each dictionary.
Auxiliary space: O(n*m).

### Convert Dictionary Value list to Dictionary Using Dictionary comprehension + map()

The program achieves this using a dictionary comprehension and the built-in function map(). The map() function is used to extract the key-value pairs from each dictionary in the input list. The dictionary comprehension is used to create a new dictionary with the extracted key-value pairs. We iterate over the length of the value list in the first dictionary in the input list to ensure that we create a dictionary for each element in the value list.

## Python3

 `# initializing list` `test_list ``=` `[{``'Gfg'` `: [``5``, ``6``, ``5``]}, ` `             ``{``'is'` `: [``10``, ``2``, ``3``]}, ` `             ``{``'best'` `: [``4``, ``3``, ``1``]}]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# Convert Dictionary Value list to Dictionary List` `# Using dictionary comprehension and map()` `res ``=` `[{k: v[i] ``for` `k, v ``in` `map``(``lambda` `x: (``list``(x.keys())[``0``],` `                                           ``list``(x.values())[``0``]), ` `                                ``test_list)} ``for` `i ``in` `range``(``len``(``list``(test_list[``0``].values())[``0``]))]`   `# printing result` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'best': 1}]```

## Python3

 `from` `collections ``import` `defaultdict`   `# initializing list` `test_list ``=` `[{``'Gfg'` `: [``5``, ``6``, ``5``]}, {``'is'` `: [``10``, ``2``, ``3``]}, {``'best'` `: [``4``, ``3``, ``1``]}]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# Convert Dictionary Value list to Dictionary List using defaultdict` `res ``=` `defaultdict(``list``)` `for` `d ``in` `test_list:` `    ``for` `key, val ``in` `d.items():` `        ``res[key].extend(val)`   `# Convert the defaultdict to a list of dictionaries` `res ``=` `[``dict``(``zip``(res.keys(), x)) ``for` `x ``in` `zip``(``*``res.values())]`   `# printing result` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'best': 1}]```

Time complexity: O(nm), where n is the length of the input list and m is the maximum length of the value lists in the input dictionaries.
Auxiliary space: O(nm), as we are creating a defaultdict and a list of dictionaries.

### Convert Dictionary Value list to Dictionary Using the Recursive method

1. Define a function dict_val_to_list that takes test_list, idx (optional with default 0), and res (optional with default None) as arguments.
2. If res is None, initialize res as a list of dictionaries with the same length as test_list.
3. If idx is greater than or equal to the length of test_list, return res.
4. Iterate over key-value pairs in the dictionary at index idx of test_list.
5. Iterate over values in the current value list.
6. Update the dictionary at the current index of res with the current key and value.
7. Make a recursive call to dict_val_to_list with the next index of test_list and the updated res.
8. Return res.

## Python3

 `# Python program for the above approach`   `# Function to convert the dictionary` `# value to list` `def` `dict_val_to_list(test_list, idx``=``0``, res``=``None``):` `  `  `    ``# initialize result list on first call` `    ``if` `res ``is` `None``:` `        ``res ``=` `[{} ``for` `_ ``in` `range``(``len``(test_list))]`   `    ``# base case: reached end of list` `    ``# of dictionaries` `    ``if` `idx >``=` `len``(test_list):` `        ``return` `res`   `    ``# iterate over key-value pairs in` `    ``# the current dictionary` `    ``for` `key, val ``in` `test_list[idx].items():` `      `  `        ``# iterate over values in the` `        ``# current value list` `        ``for` `i, ele ``in` `enumerate``(val):` `          `  `            ``# update the result dictionary` `            ``# with current key and value` `            ``res[i][key] ``=` `ele`   `        ``# recursive call to process next ` `        ``# dictionary in the list` `        ``dict_val_to_list(test_list, idx``+``1``, res)`   `    ``return` `res`   `# Driver Code`   `test_list ``=` `[{``'Gfg'``: [``5``, ``6``, ``5``]}, {``'is'``: [``10``, ``2``, ``3``]}, {``'best'``: [``4``, ``3``, ``1``]}]`   `# Print the original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `res ``=` `dict_val_to_list(test_list)`   `# Print the result` `print``(``"Records after conversion : "` `+` `str``(res))`

Output

```The original list is : [{'Gfg': [5, 6, 5]}, {'is': [10, 2, 3]}, {'best': [4, 3, 1]}]
Records after conversion : [{'Gfg': 5, 'is': 10, 'best': 4}, {'Gfg': 6, 'is': 2, 'best': 3}, {'Gfg': 5, 'is': 3, 'best': 1}]```

Time Complexity: O(N*M) where N is the length of test_list and M is the maximum length of the value lists in the dictionaries.
Space Complexity: O(N*M) for the output list of dictionaries.

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Previous
Next