How to Join Dictionary Keys or Values into a String in Python

Often, you need to represent the keys or values (or both) from a Python dictionary as a single, formatted string, typically with a specific separator between the elements. Python's str.join() method provides an efficient and idiomatic way to achieve this.

This guide demonstrates how to join dictionary keys and values into strings, including how to handle non-string elements correctly.

The Goal: Concatenating Dictionary Contents

Given a dictionary, we want to create a single string that combines either all its keys or all its values, separated by a chosen character or string (like a comma, space, newline, etc.).

Example Data:

string_dict = {'site': 'tutorialereference', 'tld': '.com', 'topic': 'python'}

mixed_dict = {'name': 'Alice', 'id': 101, 'active': True, 'score': 95.5}

key_dict = {1: 'one', 'two': 2, 3.0: 'three'}

Joining Dictionary VALUES into a String

Using str.join() with dict.values()

The dict.values() method returns a view object containing the dictionary's values. You can pass this directly to separator.join(), provided all values are already strings.

string_dict = {'site': 'tutorialreference', 'tld': '.com', 'topic': 'python'}

separator = ' '
values_string = separator.join(string_dict.values())

print(f"Dictionary: {string_dict}")
print(f"Values view: {string_dict.values()}")
print(f"Joined values ('{separator}' separator): '{values_string}'")

Output:

Dictionary: {'site': 'tutorialreference', 'tld': '.com', 'topic': 'python'}
Values view: dict_values(['tutorialreference', '.com', 'python'])
Joined values (' ' separator): 'tutorialreference .com python'

• string_dict.values(): Gets an iterable view of the values ('tutorialreference', '.com', 'python').
• ' '.join(...): Concatenates the elements from the view, placing a space between each one.

Handling Non-String Values (TypeError)

str.join() requires all elements in the iterable to be strings. If your dictionary values include numbers, booleans, or other types, passing my_dict.values() directly to join() will raise a TypeError.

mixed_dict = {'name': 'Alice', 'id': 101, 'active': True, 'score': 95.5}
separator = ', '

try:
    values_string = separator.join(mixed_dict.values())
    print(values_string)
except TypeError as e:
    print(f"Caught TypeError: {e}")

Solution: Using map(str, ...)

Convert all values to strings before joining using the map() function. map(str, iterable) applies the str() function to each item in the iterable.

mixed_dict = {'name': 'Alice', 'id': 101, 'active': True, 'score': 95.5}
separator = ', '

values_iterator = map(str, mixed_dict.values())
values_string = separator.join(values_iterator)

print(f"\nDictionary: {mixed_dict}")
print(f"Joined values (map, '{separator}' separator): '{values_string}'")

This is a concise way to handle mixed types.

Solution: Using a Generator Expression (str(v) for v in ...)

A generator expression achieves the same result as map(str, ...) and is often considered equally or more Pythonic.

mixed_dict = {'name': 'Alice', 'id': 101, 'active': True, 'score': 95.5}
separator = ' | '

values_string = separator.join(str(value) for value in mixed_dict.values())

print(f"\nDictionary: {mixed_dict}")
print(f"Joined values (genexpr, '{separator}' separator): '{values_string}'")

Examples with Different Separators

Choose the string you call .join() on to control the separator.

mixed_dict = {'name': 'Alice', 'id': 101}

print(','.join(str(v) for v in mixed_dict.values()))

print('\n'.join(str(v) for v in mixed_dict.values()))

print(''.join(str(v) for v in mixed_dict.values()))

Joining Dictionary KEYS into a String

Using str.join() with dict (Iterates Keys)

Iterating directly over a dictionary (for key in my_dict: ...) yields its keys. Therefore, you can pass the dictionary itself directly to separator.join(), if all keys are strings.

string_dict = {'site': 'tutorialreference', 'tld': '.com', 'topic': 'python'}
separator = ' - '

keys_string = separator.join(string_dict)

print(f"\nDictionary: {string_dict}")
print(f"Joined keys ('{separator}' separator): '{keys_string}'")

Handling Non-String Keys

If your dictionary keys are not all strings (e.g., integers, floats), you must convert them to strings before joining, just like with values.

key_dict = {1: 'one', 'two': 2, 3.0: 'three'}
separator = ' | '

try:
    keys_string_error = separator.join(key_dict)
    print(keys_string_error)
except TypeError as e:
    print(f"\nCaught TypeError (non-string keys): {e}")


keys_string_fixed = separator.join(str(key) for key in key_dict)

print(f"\nDictionary with mixed key types: {key_dict}")
print(f"Joined keys (fixed, '{separator}' separator): '{keys_string_fixed}'")

Examples with Different Separators

Works the same as with values.

string_dict = {'site': 'tutorialreference', 'tld': '.com', 'topic': 'python'}

print('\n'.join(string_dict)) # Newline separator

print(''.join(string_dict)) # No separator

Joining Dictionary ITEMS (Key-Value Pairs) into a String

If you want a string representing both keys and values (e.g., "key1=value1,key2=value2"), you first need to format each key-value pair into a string and then join those strings.

mixed_dict = {'name': 'Alice', 'id': 101, 'active': True}
pair_separator = '; '
kv_separator = ':'

items_string = pair_separator.join(
    f"{str(key)}{kv_separator}{str(value)}" # Format key:value, ensure both are strings
    for key, value in mixed_dict.items() # Iterate through (key, value) pairs
)

print(f"\nDictionary: {mixed_dict}")
print(f"Joined items ('{pair_separator}' separator): '{items_string}'")

• mixed_dict.items(): Provides an iterable view of (key, value) tuples.
• f"{str(key)}{kv_separator}{str(value)}": An f-string formats each pair. str() ensures both key and value are strings before formatting.
• pair_separator.join(...): Joins the formatted "key:value" strings.

Conclusion

Python's str.join() method is the standard tool for concatenating elements from an iterable into a string with a specific separator.

• To join dictionary values: Use separator.join(str(v) for v in my_dict.values()) or separator.join(map(str, my_dict.values())). Remember to convert non-string values using str().
• To join dictionary keys: Use separator.join(str(k) for k in my_dict) or separator.join(map(str, my_dict)). Convert non-string keys using str(). Iterating directly over the dictionary (join(my_dict)) works if all keys are strings.
• To join dictionary items: First, format each (key, value) pair into a single string (e.g., using an f-string and str()), then use join() on the resulting list or generator of formatted strings.

Always handle potential non-string elements by converting them to strings before passing them to join() to avoid TypeError.