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()
}

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!

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