How to Convert Comma-Separated Strings and Dict Representations to Dictionaries (and Viceversa) in Python

Converting data between string formats and Python dictionaries is a frequent necessity. You might receive configuration data as a comma-separated string of key-value pairs, need to serialize a dictionary for storage or transmission, or parse a string that looks like a dictionary literal.

This guide provides step-by-step methods for converting between comma-separated strings, string representations of dictionaries, and Python dictionaries.

Convert Comma-Separated String (Key-Value Pairs) to Dictionary

This applies when your input string looks like "key1=value1,key2=value2,...".

Using dict() and Generator Expression

The most direct approach involves splitting the string twice: first by the pair separator (e.g., comma), then by the key-value separator (e.g., equals sign). The built-in dict() constructor can accept an iterable of key-value pairs.

input_str = "name=Alice,country=Canada,language=English"
pair_separator = ','
kv_separator = '='

try:
  # Explanation of the following line:
  # 1. Split into pairs: ['name=Alice', 'country=Canada', 'language=English']
  # 2. Split each pair into [key, value]: [['name', 'Alice'], ...]
  # 3. dict() consumes the pairs
  my_dict = dict(item.split(kv_separator) for item in input_str.split(pair_separator))

  print(f"Input string: '{input_str}'") # Output: name=Alice,country=Canada,language=English
  print(f"Converted dict: {my_dict}")   # Output: Converted dict: {'name': 'Alice', 'country': 'Canada', 'language': 'English'}
  print(f"Type: {type(my_dict)}")       # Output: Type: <class 'dict'>
except ValueError:
    print(f"Error: Malformed string. Ensure each part has a '{kv_separator}'. Input: '{input_str}'")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

• input_str.split(pair_separator): Splits the main string into a list of "key=value" parts.
• (item.split(kv_separator) for item in ...): This generator expression iterates through the parts. For each part, item.split(kv_separator) splits it into a [key, value] list.
• dict(...): Takes the sequence of [key, value] lists generated and constructs a dictionary.

Using Dictionary Comprehension

A dictionary comprehension offers an alternative syntax.

input_str = "id=101,status=active,user=admin"
pair_separator = ','
kv_separator = '='

try:
    # Slightly more verbose, achieves the same result
    my_dict = {
        key: value for key, value in
        [item.split(kv_separator) for item in input_str.split(pair_separator)]
    }
    print(f"Converted dict (comprehension): {my_dict}")
    # Output: Converted dict (comprehension): {'id': '101', 'status': 'active', 'user': 'admin'}
except ValueError:
     print(f"Error: Malformed string. Ensure each part has a '{kv_separator}'. Input: '{input_str}'")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Handling Different Delimiters

Simply change the separator arguments passed to .split() if your delimiters are different (e.g., semicolon ; between pairs, colon : between key and value).

input_str_colon = "name:Bob;country:USA;language:English"
pair_separator = ';'
kv_separator = ':'

my_dict_colon = dict(item.split(kv_separator) for item in input_str_colon.split(pair_separator))
print(f"Colon-separated: {my_dict_colon}")
# Output: Colon-separated: {'name': 'Bob', 'country': 'USA', 'language': 'English'}

Converting Numeric Values

The values obtained from splitting are always strings. If they represent numbers, convert them using int() or float() within the comprehension or generator expression.

input_str_numeric = "x=10,y=25.5,z=-5"
pair_separator = ','
kv_separator = '='

# Using dict comprehension for clarity with conversion
my_dict_numeric = {
    key: float(value) if '.' in value else int(value) # Example: choose based on '.'
    for key, value in
    [item.split(kv_separator) for item in input_str_numeric.split(pair_separator)]
}

print(f"Numeric dict: {my_dict_numeric}")
# Output: Numeric dict: {'x': 10, 'y': 25.5, 'z': -5}

note

Note the types:

print({k: type(v) for k,v in my_dict_numeric.items()})

Output:

{'x': <class 'int'>, 'y': <class 'float'>, 'z': <class 'int'>}

Convert Dictionary to Comma-Separated String

To go the other way, use the str.join() method.

Joining Dictionary Keys

my_dict = {'id': 101, 'status': 'active', 'user': 'admin'}
separator = ','

# Get keys view and join them
keys_string = separator.join(my_dict.keys())
print(f"Joined keys: '{keys_string}'")  # Output: Joined keys: 'id,status,user'

Joining Dictionary Values (Handling Types)

Dictionary values can be of different types. join() requires all elements to be strings, so convert non-strings using str().

my_dict = {'name': 'Anna', 'age': 23, 'city': 'Rome'}
separator = ', ' # Comma and space

# Convert all values to string before joining
values_string = separator.join(str(value) for value in my_dict.values())
print(f"Joined values: '{values_string}'")  # Output: Joined values: 'Anna, 23, Rome'

• (str(value) for value in my_dict.values()): A generator expression ensuring every value is converted to its string representation.

Joining Dictionary Items (Key=Value Format)

To recreate the original "key=value,key=value" format:

my_dict = {'name': 'David', 'score': 88, 'level': 5}
pair_separator = ','
kv_separator = '='

# Explanation of the following line:
# 1. Create "key=value" strings for each item
# 2. Join these strings with the pair separator
dict_items_string = pair_separator.join(
    f"{key}{kv_separator}{str(value)}"
    for key, value in my_dict.items()
)

# Alternative using nested join (less readable for some):
# dict_items_string = pair_separator.join(kv_separator.join([key, str(value)])
#                                         for key, value in my_dict.items())


print(f"Joined items: '{dict_items_string}'")
# Output: Joined items: 'name=David,score=88,level=5'

• my_dict.items(): Provides view objects containing key-value tuples.
• The f-string f"{key}{kv_separator}{str(value)}" constructs each "key=value" part, ensuring the value is a string.

Convert String Representation of Dictionary to Dictionary

This applies when you have a string that looks like a Python dictionary literal, e.g., '{"key": "value"}' or "{'key': 0}".

Do NOT use eval() for this, as it's insecure.

Using ast.literal_eval() (Safe Evaluation)

The ast module's literal_eval() function safely parses a string containing a Python literal (strings, numbers, tuples, lists, dicts, sets, booleans, None) and returns the corresponding Python object.

from ast import literal_eval # Required import

string_repr_1 = "{'name': 'Eve', 'id': 42, 'active': True}" # Uses single quotes
string_repr_2 = '{"values": [1, 2, 3], "status": null}'     # Looks like JSON (null -> None)

try:
    dict_from_repr_1 = literal_eval(string_repr_1)

    print(f"Dict from literal_eval 1: {dict_from_repr_1}")  
    # Output: Dict from literal_eval 1: {'name': 'Eve', 'id': 42, 'active': True}
    print(f"Type: {type(dict_from_repr_1)}")                
    # Output: Type: <class 'dict'>

    # literal_eval handles Python's None, True, False correctly
    dict_from_repr_2 = literal_eval(string_repr_2.replace('null', 'None')) # Replace JSON null

    print(f"Dict from literal_eval 2: {dict_from_repr_2}")  
    # Output: Dict from literal_eval 2: {'values': [1, 2, 3], 'status': None}

except (ValueError, SyntaxError) as e:
    print(f"literal_eval error: Invalid literal string - {e}")

• literal_eval is much safer than eval() because it only evaluates static literals, not arbitrary code.
• It handles standard Python syntax (single/double quotes, None, True, False). It does not parse JSON null, true, false directly,so you might need replacements.

Using json.loads() (Requires Valid JSON)

If your string is guaranteed to be in valid JSON format (keys and strings must use double quotes, uses true, false, null), use the json module's loads() (load string) method.

import json # Required import

json_string = '{"name": "Frank", "city": "Paris", "isStudent": false, "grades": null}'

try:
    dict_from_json = json.loads(json_string)

    print(f"Dict from JSON: {dict_from_json}")
    # Output: Dict from JSON: {'name': 'Frank', 'city': 'Paris', 'isStudent': False, 'grades': None}
    print(f"Type: {type(dict_from_json)}") 
    # Output: Type: <class 'dict'>
except json.JSONDecodeError as e:
    print(f"JSON Decode Error: Invalid JSON string - {e}")

# This would fail json.loads because of single quotes:
invalid_json = "{'key': 'value'}"
try:
    json.loads(invalid_json)
except json.JSONDecodeError as e:
    print(f"\nAttempting to load invalid JSON failed as expected: {e}")

• json.loads() is specifically for parsing JSON-formatted strings.

Using PyYAML (Optional, for Less Strict Formats)

If your string resembles YAML (which is often less strict about quoting than JSON), the PyYAML library can be used. Requires installation (pip install pyyaml).

# Note: Requires 'pip install pyyaml'
import yaml

yaml_like_string = "{name: Anna, age: 23, tags: [a, b]}" # No quotes needed for keys/simple strings

try:
    dict_from_yaml = yaml.safe_load(yaml_like_string) # Use safe_load for untrusted input

    print(f"Dict from YAML: {dict_from_yaml}")
    # Output: Dict from YAML: {'name': 'Anna', 'age': 23, 'tags': ['a', 'b']}
except yaml.YAMLError as e:
    print(f"YAML Error: {e}")

Convert List of "Key=Value" Strings to Dictionary

If your input is a list where each element is a "key=value" string.

list_of_kv_strings = ['user_id=105', 'session=xyz789', 'role=editor']
kv_separator = '='

try:
    my_dict_from_list = dict(item.split(kv_separator) for item in list_of_kv_strings)
    
    print(f"Dict from list: {my_dict_from_list}")
    # Output: Dict from list: {'user_id': '105', 'session': 'xyz789', 'role': 'editor'}
except ValueError:
     print(f"Error: Malformed item in list. Ensure each string has a '{kv_separator}'. Input: {list_of_kv_strings}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

# Example with numeric conversion
list_numeric = ['value=100', 'ratio=0.75']
dict_numeric_from_list = {
    key: float(value) if '.' in value else int(value)
    for key, value in
    [item.split(kv_separator) for item in list_numeric]
}
print(f"Numeric dict from list: {dict_numeric_from_list}")
# Output: Numeric dict from list: {'value': 100, 'ratio': 0.75}

Conclusion

Python offers flexible tools for converting between strings and dictionaries:

• Comma-Separated String (Key=Value) -> Dict: Use str.split() twice with dict() or a dict comprehension.
• Dict -> Comma-Separated String: Use str.join() with dict.keys(), dict.values() (remember str() conversion), or dict.items() (formatting needed).
• String Resembling Dict -> Dict: Prefer ast.literal_eval() for safety. Use json.loads() only for valid JSON strings. Avoid eval().
• List of "Key=Value" Strings -> Dict: Adapt the splitting logic using dict() or a dict comprehension.

Choose the method appropriate for your specific input string format and remember to handle potential errors and data type conversions (like strings to numbers).