Python - Concatenate Dictionary string values

The task of concatenating string values in a Python dictionary involves combining the values associated with the same key across multiple dictionaries. This operation allows us to merge string data in an efficient manner, especially when dealing with large datasets .

For example, given two dictionaries a = {'gfg': 'a', 'is': 'b'} and b = {'gfg': 'c', 'is': 'd'}, the result of concatenating the string values for matching keys would be {'gfg': 'ac', 'is': 'bd'}.

Using dictionary comprehension

Dictionary comprehension is the efficient way to concatenate string values from two dictionaries. It iterates over the keys of one dictionary and concatenates the corresponding values from both dictionaries in a single step. This method is optimal for performance as it creates a new dictionary directly with the combined string values without unnecessary lookups .

a = {'gfg': 'a', 'is': 'b', 'best': 'c'}
b = {'gfg': 'd', 'is': 'e', 'best': 'f'}

res = {key: a[key] + b.get(key, '') for key in a.keys()}
print(res)

{'gfg': 'ad', 'is': 'be', 'best': 'cf'}

Explanation:

• Dictionary comprehension creates a new dictionary res by iterating over keys in a.
• a.keys() returns the keys ['gfg', 'is', 'best'].
• a[key] + b.get(key, '') concatenates values from a and b for each key.
• b.get(key, '') returns the value from b or '' if the key is not found.

Using dict.update()

dict.update() allows us to concatenate string values directly within the original dictionary. Instead of creating a new dictionary, this method modifies the existing one by appending the values from the second dictionary. It is efficient because it reduces memory overhead and modifies the dictionary in place, making it a great choice when we need to retain the structure of the original dictionary.

a = {'gfg': 'a', 'is': 'b', 'best': 'c'}
b = {'gfg': 'd', 'is': 'e', 'best': 'f'}

for key in a:
    if key in b:
        a[key] += b[key]
print(a)

{'gfg': 'ad', 'is': 'be', 'best': 'cf'}

Explanation:

• for key in a goes through the keys in dictionary a.
• if key in b ensures that the key is present in both a and b.
• a[key] += b[key] appends the value from dictionary b to the corresponding value in dictionary a.

Using map()

map() in combination with zip() provides a functional approach to concatenating string values across two dictionaries. This method avoids modifying the original dictionaries and creates a new one with concatenated values. While not as straightforward as dictionary comprehension, it’s an effective alternative when we want to apply functional programming techniques to concatenate string values from multiple dictionaries.

a = {'gfg': 'a', 'is': 'b', 'best': 'c'}
b = {'gfg': 'd', 'is': 'e', 'best': 'f'}

res = dict(map(lambda x: (x[0], a.get(x[0], '') + b.get(x[0], '')), a.keys()))
print(res)

{'g': '', 'i': '', 'b': ''}

Explanation:

• map() applies the given lambda function to each element in a.keys().
• lambda function creates a tuple for each key where the first element is the key and the second element is the concatenation of the values from dictionaries a and b for that key.
• dict() converts the iterable of tuples into a dictionary.

Using defaultdict

defaultdict from the collections module simplifies the process of concatenating string values by automatically providing a default value if a key is missing in one of the dictionaries. This method is particularly useful when we expect some keys might not be present in both dictionaries and it avoids manually checking for missing values.

from collections import defaultdict

a = {'gfg': 'a', 'is': 'b', 'best': 'c'}
b = {'gfg': 'd', 'is': 'e', 'best': 'f'}

res = defaultdict(str) # Create a defaultdict with str 
for key in a:
    res[key] = a[key] + b.get(key, '')
print(dict(res))

{'gfg': 'ad', 'is': 'be', 'best': 'cf'}

Explanation:

• for key in a iterates through each key in dictionary a.
• a[key] + b.get(key, '') concatenates values from a and b for each key, using an empty string '' if the key is missing in b.