How to Convert a Key-Value List to a Flat Dictionary in Python

Converting a list of key-value pairs into a flat dictionary is a fundamental operation in Python, commonly needed when parsing configuration data, processing database query results, transforming API responses, or restructuring data for easier access.

In this guide, you will learn multiple methods to convert key-value lists into flat dictionaries, including lists of tuples, lists of lists, and separate key/value lists. Each method is explained with clear examples and guidance on choosing the right approach.

Understanding the Problem

Given a list where each element contains a key and a value:

data = [("name", "Alice"), ("age", 25), ("city", "NYC")]

The goal is to convert it to a flat dictionary:

{"name": "Alice", "age": 25, "city": "NYC"}

The input can be a list of tuples, lists, or even two separate lists, one for keys and one for values.

Method 1: Using dict() (Recommended)

The most concise and Pythonic approach uses the built-in dict() constructor, which directly accepts an iterable of key-value pairs:

data = [("name", "Alice"), ("age", 25), ("city", "NYC")]

result = dict(data)

print(result)

Output:

{'name': 'Alice', 'age': 25, 'city': 'NYC'}

This works with any iterable of two-element sequences, whether tuples, lists, or other iterables:

data_lists = [["name", "Alice"], ["age", 25], ["city", "NYC"]]
print(dict(data_lists))

data_tuples = [("name", "Alice"), ("age", 25), ("city", "NYC")]
print(dict(data_tuples))

Output:

{'name': 'Alice', 'age': 25, 'city': 'NYC'}
{'name': 'Alice', 'age': 25, 'city': 'NYC'}

Method 2: Using Dictionary Comprehension

Dictionary comprehension provides a flexible one-liner that allows you to apply transformations or filtering during conversion:

data = [("name", "Alice"), ("age", 25), ("city", "NYC")]

result = {key: value for key, value in data}

print(result)

Output:

{'name': 'Alice', 'age': 25, 'city': 'NYC'}

Applying Transformations During Conversion

The real strength of comprehensions is the ability to modify keys or values as the dictionary is built:

data = [("Name", "alice"), ("Age", "25"), ("City", "nyc")]

result = {
    key.lower(): int(value) if value.isdigit() else value.capitalize()
    for key, value in data
}

print(result)

Output:

{'name': 'Alice', 'age': 25, 'city': 'Nyc'}

Filtering Out Unwanted Pairs

You can add a condition to exclude pairs that do not meet your criteria:

data = [("name", "Alice"), ("temp", None), ("age", 25), ("debug", "")]

result = {key: value for key, value in data if value}

print(result)

Output:

{'name': 'Alice', 'age': 25}

Method 3: Using a for Loop

An explicit loop is the most readable approach and offers full control for validation, error handling, logging, or custom duplicate-key behavior:

data = [("name", "Alice"), ("age", 25), ("city", "NYC")]

result = {}
for key, value in data:
    result[key] = value

print(result)

Output:

{'name': 'Alice', 'age': 25, 'city': 'NYC'}

Handling Duplicate Keys

When the input list contains duplicate keys, the last value wins by default in all dictionary-based methods. If you need different behavior, the loop approach gives you full control:

from collections import defaultdict

data = [("color", "red"), ("size", "large"), ("color", "blue"), ("color", "green")]

result_last = dict(data)
print("Last wins:", result_last)

result_first = {}
for key, value in data:
    if key not in result_first:
        result_first[key] = value
print("First wins:", result_first)

result_all = defaultdict(list)
for key, value in data:
    result_all[key].append(value)
print("All values:", dict(result_all))

Output:

Last wins: {'color': 'green', 'size': 'large'}
First wins: {'color': 'red', 'size': 'large'}
All values: {'color': ['red', 'blue', 'green'], 'size': ['large']}

Method 4: Using zip() with Separate Key and Value Lists

When keys and values are stored in separate lists, use zip() to pair them together before converting:

keys = ["name", "age", "city"]
values = ["Alice", 25, "NYC"]

result = dict(zip(keys, values))

print(result)

Output:

{'name': 'Alice', 'age': 25, 'city': 'NYC'}

Method 5: Using map() with dict()

When key-value pairs are encoded inside strings or other structures that need parsing, map() can extract them before conversion:

data = ["name=Alice", "age=25", "city=NYC"]

result = dict(map(lambda s: s.split("=", 1), data))

print(result)

Output:

{'name': 'Alice', 'age': '25', 'city': 'NYC'}

The split("=", 1) uses a maxsplit of 1 to ensure that values containing = characters are handled correctly.

Common Mistake: Non-Two-Element Sequences

All methods expect each element to contain exactly two items: a key and a value. Passing sequences of different lengths raises an error:

Incorrect input with three elements per tuple:

data = [("name", "Alice", "extra"), ("age", 25, "unused")]

result = dict(data)

Error:

ValueError: dictionary update sequence element #0 has length 3; 2 is required

Fix by extracting only the first two elements:

data = [("name", "Alice", "extra"), ("age", 25, "unused")]

result = {item[0]: item[1] for item in data}

print(result)

Output:

{'name': 'Alice', 'age': 25}

Converting Nested Key-Value Lists

For deeper nesting where values are themselves lists of key-value pairs, a recursive function converts each level into a dictionary:

def nested_to_dict(data):
    """Convert nested key-value pairs to a nested dictionary."""
    result = {}
    for key, value in data:
        if isinstance(value, list) and all(
            isinstance(v, (tuple, list)) and len(v) == 2 for v in value
        ):
            result[key] = nested_to_dict(value)
        else:
            result[key] = value
    return result

data = [
    ("name", "Alice"),
    ("address", [("city", "NYC"), ("zip", "10001")]),
    ("age", 25),
]

print(nested_to_dict(data))

Output:

{'name': 'Alice', 'address': {'city': 'NYC', 'zip': '10001'}, 'age': 25}

Method Comparison

Conclusion

Converting key-value lists to flat dictionaries in Python is straightforward, with several approaches available depending on your requirements:

• Use dict() for the simplest and fastest conversion of pre-formatted key-value pairs.
• Use dictionary comprehension when you need to filter entries or transform keys and values during conversion.
• Use a for loop when you need custom duplicate handling, validation, or complex logic.
• Use zip() when keys and values are stored in separate lists, but always verify that both lists have the same length to avoid silent data loss.
• Use map() with dict() when key-value pairs need to be parsed from strings or other raw formats.

Regardless of the method you choose, remember that each element must contain exactly two items, and that duplicate keys cause the last value to win by default unless you implement custom handling.