How to convert two lists into a dictionary in Python

1dict(zip(keys, values))Recommended

This is the idiomatic one-liner. zip() is lazy and dict() consumes it directly, so there's no intermediate list to build — no imports, no loop.

keys = ["name", "language", "stars"]
values = ["CompileBytes", "Python", 42]

config = dict(zip(keys, values))
print(config)
print(config["language"])

Prints {'name': 'CompileBytes', 'language': 'Python', 'stars': 42}. Dicts keep insertion order in Python 3.7+, so the result follows the order of keys. The keys list must hold hashable values — a list as a key raises TypeError: cannot use 'list' as a dict key.

2Uneven lengths and duplicate keys

zip() stops as soon as the shortest input runs out, so a mismatched pair of lists loses data without any warning. Since Python 3.10 you can pass strict=True to turn that into a ValueError instead — the safe default whenever the two lists are supposed to line up.

keys = ["host", "port", "debug"]
values = [8080, True]

# zip stops at the shorter list — "debug" is dropped without a word
print(dict(zip(keys, values)))

# strict=True (3.10+) turns that silent truncation into an error
try:
    dict(zip(keys, values, strict=True))
except ValueError as exc:
    print(f"ValueError: {exc}")

# a repeated key is not an error — the last value wins
print(dict(zip(["a", "b", "a"], [1, 2, 3])))

The first line prints {'host': 8080, 'port': True} — debug is gone. With strict=True you get ValueError: zip() argument 2 is shorter than argument 1. And duplicate keys collapse: {'a': 3, 'b': 2}, so the dict can be shorter than the lists you started with.

3A dict comprehension

When you need to transform or filter while building — normalise the keys, cast the values, skip the blanks — wrap the same zip() in a comprehension. It's one pass, and it saves you from building the dict and then cleaning it up.

headers = ["Name", "Language", "Stars", "Notes"]
row = ["CompileBytes", "Python", "42", ""]

record = {h.lower(): v for h, v in zip(headers, row) if v}
print(record)

# transform on the way in: numeric columns become ints
typed = {h.lower(): (int(v) if v.isdigit() else v) for h, v in zip(headers, row) if v}
print(typed)
print(type(typed["stars"]))

The if v clause drops the empty Notes column, so both dicts have three keys, and stars comes out as '42' in the first and 42 — a real <class 'int'> — in the second. Plain dict(zip(...)) can't do either.

4itertools.zip_longest with a fillvalue

When the lists are legitimately uneven and you want to keep every key, zip_longest() pads the short side instead of truncating. The default fill is None; pass fillvalue for your own placeholder.

from itertools import zip_longest

keys = ["host", "port", "debug"]
values = [8080, True]

print(dict(zip_longest(keys, values)))
print(dict(zip_longest(keys, values, fillvalue="unset")))

debug survives, as None and then as 'unset'. One catch: this only reads well when the keys list is the longer one. If the values list is longer, the surplus pairs all take the fill value as their key and collapse into a single entry.

5Which should you use?

6Common variation: pairs and shared defaults

If your data already arrives as (key, value) pairs, skip zip() — dict() takes any iterable of pairs. And when every key should start with the same value, there's no second list at all: dict.fromkeys() does it in one call.

pairs = [("host", "localhost"), ("port", 8080)]
print(dict(pairs))

# every key gets the same default value
print(dict.fromkeys(["verbose", "color", "trace"], False))

# and back the other way — .items() hands you the pairs again
print(list(dict(pairs).items()))

Keep dict.fromkeys() to immutable defaults. The value is evaluated once and shared by every key, so dict.fromkeys(keys, []) gives all the keys the same list object — use a comprehension like {k: [] for k in keys} instead.