py4u blog

Convert Dictionary String Values to List of Dictionaries - Python

In Python, working with data structures is a common task. Sometimes, you might encounter a situation where you have a dictionary with string values that represent lists of dictionaries. For example, you could have data coming from an external source (like a file or an API response) that is serialized in a way that the values are strings. In this blog post, we'll explore how to convert such dictionary string values into actual lists of dictionaries. This can be useful for further data manipulation, analysis, or when you need to work with the data in a more structured and Pythonic way.

2026-06

Table of Contents#

  1. Problem Scenario
  2. Using json Module
  3. Using ast.literal_eval
  4. Common Use Cases
  5. Conclusion
  6. References

Problem Scenario#

Suppose you have a dictionary like this:

data_dict = {
    "key": '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
}

The value for the key "key" is a string that represents a list of dictionaries. Your goal is to convert that string value into an actual list of dictionaries so that you can access and manipulate the data more easily.

Using json Module#

Example#

The json module in Python's standard library is great for working with JSON-like data. Since the string in our example is in a JSON-compatible format (assuming it's properly formatted), we can use it to convert the string to a list of dictionaries.

import json
 
data_dict = {
    "key": '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
}
 
# Convert the string value to a list of dictionaries
converted_list = json.loads(data_dict["key"])
 
print(converted_list)
# Output: [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]

Best Practices#

  • Input Validation: Before using json.loads, make sure the string is in a valid JSON format. You can use a try-except block to handle any json.JSONDecodeError that might occur if the string is malformed.
try:
    converted_list = json.loads(data_dict["key"])
except json.JSONDecodeError as e:
    print(f"Error decoding JSON: {e}")
  • Use for JSON-like Data: The json module is designed for JSON data. If your string follows the JSON syntax rules (e.g., double quotes for strings, proper commas and braces), it's a reliable choice.

Using ast.literal_eval#

Example#

The ast.literal_eval function from the ast (Abstract Syntax Trees) module can also be used to evaluate a string as a Python literal. This can be handy if the string represents a Python data structure like a list of dictionaries.

import ast
 
data_dict = {
    "key": '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]'
}
 
# Convert the string value to a list of dictionaries
converted_list = ast.literal_eval(data_dict["key"])
 
print(converted_list)
# Output: [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]

Caution and Best Practices#

  • Security Consideration: ast.literal_eval is safer than eval (which can execute arbitrary code), but it still has some risks. Only use it with trusted input. If the string comes from an untrusted source (like user input), it's better to use json.loads if the data is JSON-compatible as it has more restrictions on what it can parse.
  • Python Syntax Compliance: The string must be a valid Python literal. For example, it should use single or double quotes correctly for strings within the dictionaries (but in Python, both are allowed for literals).

Common Use Cases#

  • Reading from Files: When you read data from a text file where the values are stored as strings representing lists of dictionaries (e.g., a simple configuration file format).
  • API Responses: Some APIs might return data in a format where certain fields are strings that need to be parsed into more complex data structures like lists of dictionaries.
  • Data Serialization/Deserialization: In cases where you serialize data (e.g., save to a database as a string) and then need to deserialize it back to its original Python data structure form.

Conclusion#

In this blog post, we've looked at two ways to convert dictionary string values to lists of dictionaries in Python. The json module is great for JSON-compatible strings, offering good validation and security for that format. ast.literal_eval can be useful for valid Python literal strings but requires more caution regarding input trust. Depending on your data source and its format, you can choose the appropriate method. Both methods expand your ability to work with complex data structures that might come in a serialized string form.

References#