5 Best Ways to Convert a Python Dictionary to a Multiline String

Python developers often need to transform a dictionary object into a formatted multiline string, whether for debugging, logging, or other display purposes. The desired output involves each key-value pair from the dictionary appearing on a new line, for legibility. For instance, taking the input {'a': 1, 'b': 2, 'c': 3}, the output should look like

'a: 1
b: 2
c: 3'

Method 1: The JSON Dump

This method uses the json module in Python to serialize a dictionary into a string with a custom indentation. The json.dumps() function takes the dictionary and an indent parameter specifying the number of spaces per indentation level, transforming the dictionary into a pretty-printed string.

Here’s an example:

import json
my_dict = {'a': 1, 'b': 2, 'c': 3}
pretty_string = json.dumps(my_dict, indent=4)
print(pretty_string)

Output:

{
    "a": 1,
    "b": 2,
    "c": 3
}

This code snippet takes the dictionary my_dict and converts it into a multiline string with 4 spaces for indentation, resulting in a readable, structured format.

Method 2: Join and Format

The join and format method leverages string manipulation to concatenate each key-value pair as a string, using newline characters to separate lines. It utilizes list comprehension to create a list of strings for each key-value pair, which is then joined into one multiline string.

Here’s an example:

my_dict = {'a': 1, 'b': 2, 'c': 3}
multiline_string = '\n'.join([f'{k}: {v}' for k, v in my_dict.items()])
print(multiline_string)

Output:

a: 1
b: 2
c: 3

This snippet iterates through my_dict items, formatting each pair and then joining them with newline characters to construct the desired multiline string.

Method 3: The For-Loop and Append

This method iterates over the dictionary’s items in a for-loop, appending the key-value pairs to a string, each followed by a newline character. It’s a simple and direct approach, suitable for when you want to manually control the formatting.

Here’s an example:

my_dict = {'a': 1, 'b': 2, 'c': 3}
lines = []
for key, value in my_dict.items():
    lines.append(f'{key}: {value}')
multiline_string = "\n".join(lines)
print(multiline_string)

Output:

a: 1
b: 2
c: 3

This snippet uses a for-loop to create a list of strings for each dictionary entry and then concatenates this list into a multiline string using the join method.

Method 4: Using pprint

The pprint module (short for “pretty-print”) is designed to print out complex data structures in Python in a way that’s readable to humans, which can also be used to produce a multiline string from a dictionary. The pprint.pformat() function can return the formatted string instead of printing it.

Here’s an example:

from pprint import pformat
my_dict = {'a': 1, 'b': 2, 'c': 3}
multiline_string = pformat(my_dict)
print(multiline_string)

Output:

{'a': 1, 'b': 2, 'c': 3}

The pformat() function converts the dictionary my_dict into a string with a format that makes it visually easy to trace the structure of the dictionary.

Bonus One-Liner Method 5: Using str() and replace()

A one-liner method involves using the str() method to convert the dictionary to a string and then replacing the commas with newline characters, and the curly braces with empty strings if a more compact output is desired.

Here’s an example:

my_dict = {'a': 1, 'b': 2, 'c': 3}
multiline_string = str(my_dict)[1:-1].replace(', ', '\n')
print(multiline_string)

Output:

"a": 1
"b": 2
"c": 3

This one-liner takes the string representation of my_dict, strips the curly braces, and replaces the commas and spaces with newline characters to create our multiline string.

Summary/Discussion

• Method 1: JSON Dump. Strengths: Easy to read format with standardized JSON indentation. Weaknesses: Adds double quotes to dictionary keys and values.
• Method 2: Join and Format. Strengths: Flexible customization of format/style. Weaknesses: Requires more code for custom formatting.
• Method 3: The For-Loop and Append. Strengths: Explicit control over the format. Weaknesses: Slightly more verbose than other methods.
• Method 4: Using pprint. Strengths: Pretty-prints any data structure and works well with nested dictionaries. Weaknesses: Output format is more rigid and not as customizable.
• Method 5: One-Liner using str() and replace(). Strengths: Quick and concise. Weaknesses: Limited control over formatting, and can be less readable with complex or nested dictionaries.