Skip to content
Tutorial Reference

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

How to convert comma-separated key-value strings and dictionary strings to Python dictionaries using dict(), ast.literal_eval(), and json.loads(), with examples for error handling and type conversion.

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:
  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:
    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}")
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}")

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 = '='

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}")

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 = ','

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

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 = '='

dict_items_string = pair_separator.join(
    f"{key}{kv_separator}{str(value)}"
    for key, value in my_dict.items()
)



print(f"Joined items: '{dict_items_string}'")
  • 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}")  
    print(f"Type: {type(dict_from_repr_1)}")                

    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}")  

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}")
    print(f"Type: {type(dict_from_json)}") 
except json.JSONDecodeError as e:
    print(f"JSON Decode Error: Invalid JSON string - {e}")

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).

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}")
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}")
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}")

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}")

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).

Navigation