5 Best Ways to Convert Python Iterable to Dictionary

Converting iterables to dictionaries is a common task in Python. Iterables may include lists, tuples, or even other dictionaries you need to restructure. The desired output is a dictionary, which is a collection of key-value pairs providing a way to store data that needs to be accessible by key lookups. This article discusses five methods to convert an iterable to a dictionary, showcasing the variety of approaches available in Python.

Method 1: Using a Dictionary Comprehension

Dictionary comprehension is a concise and expressive way to transform lists, tuples, or other iterables into dictionaries. It follows the syntax of {key: value for (key, value) in iterable}, making it suitable for iterables that naturally pair into key-value tuples.

Here’s an example:

iterable = [('a', 1), ('b', 2), ('c', 3)]
dictionary = {k: v for k, v in iterable}
print(dictionary)

Output:

{'a': 1, 'b': 2, 'c': 3}

Using dictionary comprehension, we iterate over the iterable, which contains tuples with two elements, and treat the first as the key and the second as the value, building the resulting dictionary in one line of code.

Method 2: Using the dict() Constructor with zip()

The built-in dict() constructor paired with zip() can merge two iterables into a single dictionary. The zip() function pairs elements from two iterables, resulting in an iterable of tuples which dictate the key-value pairs.

Here’s an example:

keys = ['one', 'two', 'three']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print(dictionary)

Output:

{'one': 1, 'two': 2, 'three': 3}

This approach is straightforward when you have separate lists of keys and values that you want to link into a dictionary. The dict() constructor transforms the zipped pairs into dictionary items.

Method 3: Using the dict.fromkeys() Method

This method is excellent when you want to initialize a dictionary with the same value for each key. The dict.fromkeys() method creates a new dictionary with keys from the iterable and a single, optional default value for all the keys.

Here’s an example:

keys = ['a', 'b', 'c']
default_value = 0
dictionary = dict.fromkeys(keys, default_value)
print(dictionary)

Output:

{'a': 0, 'b': 0, 'c': 0}

In this example, we create a dictionary with keys from the list and initialize all values to 0 using dict.fromkeys(). It’s a quick way to initialize a dictionary when you don’t need to assign unique values per key.

Method 4: Using a For Loop

For those preferring explicit iteration, using a for loop to construct a dictionary from an iterable allows for custom logic and processing of keys and values. This is the most versatile and customizable method.

Here’s an example:

iterable = ['hello', 'world', 'python']
dictionary = {}
for i, item in enumerate(iterable):
    dictionary[i] = item
print(dictionary)

Output:

{0: 'hello', 1: 'world', 2: 'python'}

The for loop assigns each element in the iterable a dictionary key based on its index using the enumerate() function. This approach allows for additional logic during the iteration.

Bonus One-Liner Method 5: Using Dictionary Unpacking in Python 3.5+

Dictionary unpacking employs the ** operator to merge dictionaries into a single one. In Python 3.5+, you can combine this with dictionary comprehension for on-the-fly transformations.

Here’s an example:

iterable = [('a', 1), ('b', 2)]
dictionary = {**dict(iterable)}
print(dictionary)

Output:

{'a': 1, 'b': 2}

This approach uses dictionary unpacking to create a new dictionary. It’s compact but best suited for cases where your iterable is already in the form of key-value pairs, similar to dictionary comprehension.

Summary/Discussion

• Method 1: Dictionary Comprehension. Fast and idiomatic. Best for iterables of paired items.
• Method 2: dict() with zip(). Simple and clean. Ideal when keys and values are in separate iterables.
• Method 3: dict.fromkeys(). Quick and efficient for default value dictionaries. Not suitable for unique value assignments.
• Method 4: For Loop. Highly customizable. Offers complete control but is more verbose.
• Method 5: Dictionary Unpacking. Elegant one-liner. Requires Python 3.5+ and is not well-suited for iterables not already paired into key-values.