# Convert Two Lists Into a Dictionary in Python Using for Loop

In this blog, we will explore a Python program to convert/combine two lists into a dictionary using for loop. We will walk through a code example that demonstrates the step-by-step process of transforming lists into a dictionary using a nested loop. By understanding this process, you will gain insights into the logic behind it and be able to apply it in various scenarios.

In programming, there are often situations where we need to combine two lists into a dictionary. This process can be incredibly useful when dealing with data manipulation and organization. While there are built-in methods available to achieve this, it’s equally important to understand the underlying logic and operations involved.

So, let’s explore how to convert two lists into a dictionary in Python using for loop.

## Python Program to Convert / Combine Two Lists Into a Dictionary Using for Loop

# Convert or Combine Two Lists Into a Dictionary in python using Naive Method/for loop

# Python3 code to demonstrate
# conversion of lists to dictionary
# using naive method

# initializing lists
test_keys = ["Chandan", "Pratik", "Praful"]
test_values = [3, 5, 7]

# Printing original keys-value lists
print("Original key list is : " + str(test_keys))
print("Original value list is : " + str(test_values))

# using naive method
# to convert lists to dictionary
res = {}
for key in test_keys:
for value in test_values:
res[key] = value
test_values.remove(value)
break

# Printing resultant dictionary
print("Resultant dictionary is : " + str(res))

### Explanation of the code

Initialising the Lists

We start by initialising two lists, test_keys and test_values, which contain the keys and values, respectively, that we want to combine into a dictionary.

Printing the Original Lists

We print the original key and value lists using the print() function, converting the lists to strings using the str() function.

Converting Lists to Dictionary Using Naive Method

We create an empty dictionary res to store the resultant dictionary. We use a nested for loop to iterate over each key in the test_keys list and each value in the test_values list. Inside the loop, we assign the current key with the current value to the res dictionary using the assignment statement res[key] = value. We then remove the assigned value from the test_values list using the remove() method. To ensure that only one value is assigned to each key, we break out of the inner loop using the break statement.

Printing the Resultant Dictionary

Finally, we print the resultant dictionary res using the print() function, converting it to a string using the str() function.

#### Output:

Original key list is : ['Chandan', 'Pratik', 'Praful']
Original value list is : [3, 5, 7]
Resultant dictionary is : {'Chandan': 3, 'Pratik': 5, 'Praful': 7}

As we can see from the output, the original key-value lists are printed first. Then, the code uses a for loop to iterate over the keys and values lists and creates a dictionary by pairing the corresponding elements of both lists. The resultant dictionary is then printed.

#### Here are a few alternative methods:

Using enumerate() function:

It provides a concise and readable solution. It explicitly associates the values with their indices in a compact form, avoiding the need for additional lambda functions or explicit loops.

Using the map() function:

You can simplify the code by applying the lambda function to each corresponding element of the two lists, creating a map object. By converting the map object into a list of tuples and then into a dictionary, you achieve the desired result of converting the two lists into a dictionary.

Using dict() with zip() function:

Instead of using a list comprehension with enumerate(), you can directly pass the two lists to zip(). zip() combines the elements of both lists into pairs, and dict() converts the resulting list of pairs into a dictionary. This method simplifies the code by eliminating the need for enumerate() and the list comprehension.

Using a dictionary comprehension:

You can use dictionary comprehension to iterate over both lists simultaneously and construct the dictionary in a more concise way. The dictionary comprehension creates key-value pairs directly from the two lists without needing zip() or dict().

In our code, we used the nested loop and the naive approach as it allows for more flexibility in handling situations where the lengths of the key and value lists are different. It assigns values to keys until one of the lists is exhausted, ensuring that no data is left out. In the naive method, if a key appears multiple times in the test_keys list, it will be overwritten with the last corresponding value. This can be desirable in some cases, depending on the specific requirements of your program.

#### Conclusion

In conclusion, the provided code demonstrates a naive method of converting two separate lists into a dictionary in Python. By iterating through each key in the test_keys list and each value in the test_values list, the code assigns the corresponding value to each key in a new dictionary. Although this approach achieves the desired result, it relies on a nested loop and modifies the test_values list during iteration.

While this code provides a basic understanding of how to combine lists into a dictionary, it may not be the most efficient or recommended method in all scenarios. Depending on the complexity and size of the data, alternative approaches such as using the zip() function or dictionary comprehension may offer better performance and readability.

When working with lists and dictionaries in Python, it is important to choose the appropriate method based on the specific requirements of your task. Understanding different techniques for data manipulation allows you to optimize your code and improve its overall efficiency.

Q: How does the code initialize the key and value lists?

A: The code initializes the key list (test_keys) and value list (test_values) by assigning them with specific values or by obtaining them from other parts of the program.

Q: Why are the original key and value lists printed?

A: Printing the original key and value lists helps us verify the initial data before the conversion process begins, providing a clear understanding of the input.

Q: How does the code convert lists to a dictionary?

A: The code uses nested loops to iterate over each key in the test_keys list and each value in the test_values list. It assigns each key with its corresponding value in a new dictionary (res) using the assignment statement res[key] = value.

Q: Why is the test_values list modified during the conversion process?

A: The test_values list is modified to ensure that each key is associated with a unique value. After assigning a value to a key, that value is removed from the test_values list to avoid assigning it to any other key.

Q: What happens if the key and value lists have different lengths?

A: If the key and value lists have different lengths, the conversion process will stop once all the values have been assigned to keys. Any remaining keys without corresponding values will not be included in the resultant dictionary.