Easily Pretty Print Python Dictionaries: A Beginner's Guide

Easily Pretty Print Python Dictionaries: A Beginner's Guide

MoeNagy Dev

Exploring the Art of Pretty Printing Dictionaries in Python

Importance of Pretty Printing Dictionaries

Understanding the need for readable and well-formatted output is crucial in Python development. Dictionaries, being one of the fundamental data structures, are often used to store and represent complex data. However, the default output format for dictionaries can be difficult to read, especially when dealing with large or nested structures. Pretty printing dictionaries can enhance code readability and maintainability, making it easier for developers to understand and work with the data.

The Built-in print() Function and Its Limitations

When printing dictionaries with the print() function, the output can be difficult to interpret, especially for complex or nested structures. The default output format may not provide the desired level of readability and organization.

my_dict = {'name': 'John Doe', 'age': 30, 'city': 'New York'}
# Output: {'name': 'John Doe', 'age': 30, 'city': 'New York'}

While this output is functional, it may not be the most user-friendly, especially when working with larger or more complex dictionaries.

Introducing the pprint Module

To address the limitations of the default print() function, Python provides the pprint (pretty print) module. This module offers a more visually appealing and structured way of displaying dictionary data.

import pprint

The pprint module provides the pprint() function, which can be used to pretty print dictionaries and other data structures.

Basic Usage of pprint.pprint()

To use the pprint() function, simply pass your dictionary as an argument:

my_dict = {'name': 'John Doe', 'age': 30, 'city': 'New York'}
# Output:
# {'age': 30,
#  'city': 'New York',
#  'name': 'John Doe'}

The output is now much more readable, with the keys and values organized in a clear and structured manner.

Customizing the Pretty Print Output

The pprint module offers several options to customize the pretty print output to suit your specific needs.

Adjusting the Indent Level

You can control the indentation level of the output by passing the indent parameter to pprint.pprint():

pprint.pprint(my_dict, indent=4)
# Output:
# {   'age': 30,
#     'city': 'New York',
#     'name': 'John Doe'}

Controlling the Maximum Width of the Output

By default, pprint.pprint() will try to fit the output within 80 characters per line. You can change this behavior by setting the width parameter:

pprint.pprint(my_dict, width=40)
# Output:
# {'age': 30,
#  'city': 'New York',
#  'name': 'John Doe'}

Specifying the Depth of Nested Structures

When working with nested dictionaries, you can control the depth of the output using the depth parameter:

nested_dict = {'person': {'name': 'John Doe', 'age': 30}, 'address': {'city': 'New York', 'state': 'NY'}}
pprint.pprint(nested_dict, depth=1)
# Output:
# {'address': {...}, 'person': {...}}

This is useful when you want to focus on the top-level structure without getting overwhelmed by the details of the nested elements.

Handling Special Characters and Unicode

The pprint module handles special characters and Unicode data gracefully. It ensures that the output is correctly encoded and displayed, even for non-ASCII characters.

my_dict = {'name': 'John Doe', 'city': 'Montréal'}
# Output:
# {'city': 'Montréal', 'name': 'John Doe'}

In this example, the non-ASCII character 'é' in 'Montréal' is properly displayed.

Sorting Dictionary Keys

By default, the keys in the pretty printed output are not sorted. You can sort the keys alphabetically by using the sort_dicts parameter:

my_dict = {'name': 'John Doe', 'age': 30, 'city': 'New York'}
pprint.pprint(my_dict, sort_dicts=True)
# Output:
# {'age': 30, 'city': 'New York', 'name': 'John Doe'}

This can be particularly useful when working with large dictionaries to maintain a consistent and organized output.

Integrating pprint with Logging

The pprint module can be seamlessly integrated with Python's logging system to enhance the readability of log entries that involve dictionary data.

import logging
import pprint
logging.basicConfig(level=logging.INFO, format='%(message)s')
my_dict = {'name': 'John Doe', 'age': 30, 'city': 'New York'}'User information:\n%s', pprint.pformat(my_dict))
# Output:
# User information:
# {'age': 30,
#  'city': 'New York',
#  'name': 'John Doe'}

By using pprint.pformat() to format the dictionary, you can ensure that the log entries are easy to read and understand, even when dealing with complex data structures.

Working with Nested Dictionaries

The pprint module handles nested dictionary structures gracefully, maintaining the clarity and organization of the output.

nested_dict = {'person': {'name': 'John Doe', 'age': 30}, 'address': {'city': 'New York', 'state': 'NY'}}
# Output:
# {'address': {'city': 'New York', 'state': 'NY'},
#  'person': {'age': 30, 'name': 'John Doe'}}

The nested structure is clearly visible, making it easier to understand the relationships between the different elements of the dictionary.

Combining pprint with Other Formatting Techniques

While the pprint module provides a powerful and flexible way to pretty print dictionaries, you can also combine it with other string formatting techniques to enhance the visual presentation of your data.

my_dict = {'name': 'John Doe', 'age': 30, 'city': 'New York'}
formatted_output = f"Name: {my_dict['name']}\nAge: {my_dict['age']}\nCity: {my_dict['city']}"
# Output:
# 'Name: John Doe\n'
# 'Age: 30\n'
# 'City: New York'

In this example, we use f-strings to format the dictionary data and then pass the resulting string to pprint.pprint() for a visually appealing output.

Exploring Alternative Pretty Print Options

While the pprint module is a powerful and widely-used tool for pretty printing dictionaries in Python, there are also other options available:

  • json.dumps(): The json module provides the dumps() function, which can be used to pretty print dictionaries in a JSON-style format.
  • Third-party libraries: Libraries like rich and tabulate offer alternative pretty print solutions with additional features and customization options.

The choice of the appropriate pretty print method will depend on your specific use case and personal preferences.

Best Practices and Considerations

When using the pprint module, consider the following best practices and considerations:

  • Choose the appropriate pretty print method for your use case: Evaluate the trade-offs between readability, performance, and the specific requirements of your project.
  • Balance readability and performance: While pretty printing can enhance the readability of your code, it's important to consider the performance impact, especially when dealing with large or frequently printed dictionaries.
  • Experiment and explore: The pprint module offers a wide range of customization options, so don't hesitate to experiment and find the configuration that works best for your needs.


In this tutorial, we have explored the art of pretty printing dictionaries in Python using the pprint module. We've covered the importance of readable and well-formatted output, the limitations of the built-in print() function, and the various features and customization options provided by the pprint module.

By mastering the techniques presented in this tutorial, you can enhance the readability and maintainability of your Python code, making it easier to understand and work with dictionary data. Remember to experiment, explore, and find the approach that best suits your specific use cases.

Working with Data Structures


Lists are versatile data structures in Python that can store collections of items. They can hold elements of different data types, including numbers, strings, and even other data structures like lists and dictionaries.

Here's an example of creating a list and performing various operations on it:

# Creating a list
fruits = ['apple', 'banana', 'cherry']
# Accessing elements
print(fruits[0])  # Output: 'apple'
print(fruits[-1])  # Output: 'cherry'
# Modifying elements
fruits[1] = 'orange'
print(fruits)  # Output: ['apple', 'orange', 'cherry']
# Adding elements
print(fruits)  # Output: ['apple', 'orange', 'cherry', 'mango']
# Removing elements
del fruits[2]
print(fruits)  # Output: ['apple', 'orange', 'mango']


Tuples are similar to lists, but they are immutable, meaning their elements cannot be modified after creation. Tuples are defined using parentheses () instead of square brackets [].

# Creating a tuple
point = (3, 4)
print(point)  # Output: (3, 4)
# Accessing elements
print(point[0])  # Output: 3
print(point[1])  # Output: 4
# Trying to modify a tuple element
# point[0] = 5  # TypeError: 'tuple' object does not support item assignment


Dictionaries are unordered collections of key-value pairs. They are defined using curly braces {} and each key-value pair is separated by a colon :.

# Creating a dictionary
person = {
    'name': 'John Doe',
    'age': 30,
    'city': 'New York'
# Accessing values
print(person['name'])  # Output: 'John Doe'
print(person['age'])  # Output: 30
# Adding/modifying key-value pairs
person['email'] = ''
person['age'] = 31
print(person)  # Output: {'name': 'John Doe', 'age': 31, 'city': 'New York', 'email': ''}
# Removing key-value pairs
del person['city']
print(person)  # Output: {'name': 'John Doe', 'age': 31, 'email': ''}


Sets are unordered collections of unique elements. They are defined using curly braces {} or the set() function.

# Creating a set
colors = {'red', 'green', 'blue'}
print(colors)  # Output: {'red', 'green', 'blue'}
# Adding elements
print(colors)  # Output: {'red', 'green', 'blue', 'yellow'}
# Removing elements
print(colors)  # Output: {'red', 'blue', 'yellow'}
# Checking membership
print('red' in colors)  # Output: True
print('purple' in colors)  # Output: False

Working with Functions

Functions are reusable blocks of code that perform specific tasks. They can take inputs (parameters) and return outputs.

# Defining a function
def greet(name):
    print(f"Hello, {name}!")
# Calling the function
greet("Alice")  # Output: Hello, Alice!
# Functions with return values
def add_numbers(a, b):
    return a + b
result = add_numbers(5, 3)
print(result)  # Output: 8

Function Arguments

Python functions can have different types of arguments, including positional arguments, keyword arguments, and default arguments.

# Positional arguments
def calculate_area(length, width):
    return length * width
print(calculate_area(5, 3))  # Output: 15
# Keyword arguments
print(calculate_area(width=4, length=6))  # Output: 24
# Default arguments
def greet(name, message="Hello"):
    print(f"{message}, {name}!")
greet("Bob")  # Output: Hello, Bob!
greet("Alice", "Hi")  # Output: Hi, Alice!

Lambda Functions

Lambda functions, also known as anonymous functions, are small, one-line functions that can be defined without a name.

# Using a regular function
def square(x):
    return x ** 2
print(square(4))  # Output: 16
# Using a lambda function
square_lambda = lambda x: x ** 2
print(square_lambda(4))  # Output: 16

Working with Modules and Packages

Python's standard library provides a wide range of modules that you can use in your programs. You can also create your own modules and packages to organize your code.

# Importing a module
import math
print(math.pi)  # Output: 3.141592653589793
# Importing a specific function from a module
from math import sqrt
print(sqrt(16))  # Output: 4.0
# Importing a module with an alias
import datetime as dt
print(  # Output: 2023-04-26 12:34:56.789012

Handling Errors and Exceptions

Python has built-in mechanisms to handle errors and exceptions that may occur during program execution.

# Handling a ZeroDivisionError
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero")
# Handling multiple exceptions
    int_value = int("abc")
except ValueError:
    print("Error: Invalid integer value")
except Exception as e:
    print(f"Unexpected error: {e}")


In this tutorial, you've learned about various data structures in Python, including lists, tuples, dictionaries, and sets. You've also explored the concept of functions, their different types of arguments, and the use of lambda functions. Additionally, you've gained knowledge about working with modules and packages, as well as handling errors and exceptions in your Python programs.

These concepts are essential building blocks for writing more complex and robust Python applications. By understanding and applying these techniques, you'll be well on your way to becoming a proficient Python programmer.

MoeNagy Dev