Update a dict with list values with another dict

Question

The code below works. The question is if there is a better and more elegant (maintainable) way.

The task is to update a Python dictionary which values are lists with another dictionary with the same structure (values are lists). The usual dict.update() doesn't work because values (the lists) are replaced not updated (via list.extend()).

Example:

a = {'A': [1, 2], 'C': [5]}
b = {'X': [8], 'A': [7, 921]}

Using dict.update() would result in

{'A': [7, 921], 'C': [5], 'X': [8]}

But A should become [1, 2, 7, 921].

Here is my working solution:

#!/usr/bin/env python3
from typing import Any
def update_dict_with_list_values(
 a: dict[Any,list], b: dict[Any,list]) -> dict[Any,list]:
 """Update a dictionary and its list values from another dict."""
 # create a local deep copy
 a = a.copy()
 for key in a:
 try:
 # remove the list
 b_value = b.pop(key)
 except KeyError:
 pass
 else:
 # extend the list
 a[key] = a[key] + b_value
 # add the rest of keys that are not present in the dict to update
 a.update(b)
 return a
if __name__ == '__main__':
 a = {
 'A': [1, 2],
 'C': [5]
 }
 b = {
 'X': [8],
 'A': [7, 921]
 }
 c = update_dict_with_list_values(a, b)
 print(c) # -> {'A': [1, 2, 7, 921], 'C': [5], 'X': [8]}

Answer 1

Avoid conditionals by using defaultdict. There is only one case: you want to extend-merge lists from the second dictionary, with the target defaulting to an empty list.

from collections import defaultdict
from typing import Any, Iterable
def update_dict_with_list_values(
 a: dict[Any, list], b: dict[Any, Iterable],
) -> dict[Any, list]:
 """Update a dictionary and its list values from another dict."""
 union = defaultdict(list, a)
 for k, values in b.items():
 union[k].extend(values)
 return union

This assumes that you don't mind mutating the value lists of a, which is a risky assumption indeed. To avoid this you would deep-copy a first, via something like

 union = defaultdict(list, (
 (k, list(v)) for k, v in a.items()
 ))

Or, for a very different approach which is naturally immune to side-effect concerns,

return {
 k: a.get(k, []) + b.get(k, [])
 for k in a.keys() | b.keys()
}

• buhtz: Because I don't understand defaultdict at all I don't get its advantage in the current case.
• Stef: @buhtz If you don't want defaultdict, you can use method dict.setdefault instead. That is, for a key k in b, you can replace if k in d: a[k].extend(b[k]) else: d[k] = list(b[k]) with the equivalent a.setdefault(k, []).extend(b[k]).

Answer 2

Bottom line you need only 2 cases:

1. if a b key is present in a, merge values (extend for that matter)
2. if a b key is not present in a, then assign it to a

Assuming you're only expecting lists as values, you could write something like this:

def update_dict_with_list_values(
 a: dict[Any, list[Any]],
 b: dict[Any, list[Any]],
) -> dict[Any, list[Any]]:
 """Update a dictionary and its list values from another dict."""
 for key, value in b.items():
 if key in a:
 a[key].extend(value)
 else:
 a[key] = value
 return a

I would recommend avoiding single-letter variable names!

Hope that helps!

• buhtz: Mhm... The code is easier to read but less efficient because of if statements. I tried to avoid them. And I would hypotize that in a short function like this it is acceptable.
• janos: @buhtz Why do you think it's less efficient? Exception handling tends to be much slower than conditionals.
• buhtz: But exception only need to be handled when they occur not earlier.
• Reinderien: You do not need two cases.
• Stef: Note that a[key] = value should probably be changed into the safer a[key] = list(value), or a[key] = value.copy(), otherwise future modifications ofb might result in accidental modifications of a.

Answer 3

Based on that answer I suggest a solution avoiding if. The key point here is that don't iterate over the dict to update (the target) but the dict that is updated with (the source).

def update_dict_with_list_values(
 a: dict[Any,list], b: dict[Any,list]) -> dict[Any,list]:
 """Update a dictionary and its list values from another dict."""
 for key, value in b.items():
 try:
 a[key].extend(value)
 except KeyError:
 a[key] = value
 return a

• janos: The .copy() function of a dict is not a deep copy, it's a shallow copy.
• buhtz: @RichardNeumann Just a typo. You are also able to edit and correct foreign answers by the way. ;)
• Stef: The line a = copy.deepcopy(a) should probably be removed; or if you really want to have it, should should add a warning in the docstring explaining that update_dict_with_list_values will make deepcopies and discard the original objects in a.
• buhtz: You are right. Using a copy would be more a join_dict_with_list_values() then update...().
• Stef: Yes; but even for a join function, you should probably just write a = {k: list(v) for k,v in a.items()} rather than a = copy.deepcopy(a), so as to make copies of the lists without making deepcopies of possible objects in the lists. (Also, in this case I'd recommend calling the return dict c = {k: list(v) for k,v in a.items()} rather than giving it the same name a, which is confusing and hides the fact that it's a local variable)