Python | Initialize dictionary with multiple keys

Sometimes, while working with dictionaries, we might have a problem in which we need to initialize the dictionary with more than one key with the same value. This application requirement can be in domains of web development in which we might want to declare and initialize simultaneously. Let’s discuss certain ways in which this task can be performed.

Method #1: Using loop 

We can have a loop that performs this particular task. But this just partially solves our problem of multiple additions but the dictionary has to be declared beforehand for this. 

The original dictionary : {}
Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time complexity: O(n), where n is the number of keys in the test_keys list.
Auxiliary space: O(n), where n is the number of keys in the test_keys list.

Method #2: Using fromkeys()

This function is used to actually perform both tasks of multiple assignments and declarations with a single statement. We also use * operator to pack the values together into a dictionary. 

Dictionary after Initializing multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time complexity: O(n), where n is the length of the test_keys list.
Auxiliary space: O(n), as we are creating a dictionary with n key-value pairs.

Method #3: Use repeat() function

This is another way to initialize a dictionary with multiple keys using the repeat() function.

Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time Complexity: O(n) 
Auxiliary Space: O(n)

Method 4: Using dictionary comprehension:

Approach:

1. Initialize a list of keys test_keys with three elements ‘gfg’, ‘is’, and ‘best’.
2. Use dictionary comprehension to create a dictionary res with keys as the elements in test_keys and values as 4.
3. Print the result of the dictionary res after updating the values.

Below is the implementation of the above approach:

Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time complexity: O(n), where n is the number of keys in the dictionary
Auxiliary space: O(n), where n is the number of keys in the dictionary. This is because we need to store the dictionary in memory.

Method #5: Using dict.fromkeys() method

1. Create an empty dictionary test_dict using {}.
2. Initialize a list test_keys with the keys you want to add to the dictionary.
3. Use the dict.fromkeys() method to create a dictionary with the keys from test_keys and a default value of 4. Assign the resulting dictionary to test_dict.
4. Print the updated dictionary.

The original dictionary : {}
Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time complexity: O(n), where n is the number of keys in test_keys.
Auxiliary space: O(n), where n is the number of keys in test_keys.

Method #6: Using zip() function and dictionary comprehension:

Algorithms:

1. Create a list of keys to be used to initialize the dictionary.
2. Create a list of default values that will be used for each key.
3. Use the zip() function to combine the keys and default values into a list of tuples.
4. Use dictionary comprehension to convert the list of tuples into a dictionary.
5. Print the original Dictionary and the updated dictionary.

Below is the implementation of the above approach:

Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time Complexity: O(N), where N is the number of keys in the dictionary. 
Auxiliary Space: O(N), where N is the number of keys in the dictionary.

Method#7: Using the Recursive method:

In this implementation, the function init_dict takes a list of keys and a value as input and returns a new dictionary where each key in keys is associated with the same value.

The implementation uses recursion to build the dictionary. The base case is when key is empty, in which case the function returns an empty dictionary. Otherwise, the function creates a dictionary with a single key-value pair as {keys[0]: value} and then calls itself recursively with the remaining keys keys[1:]. The result of the recursive call is merged with the current key-value pair using the unpacking operator ** to create a new dictionary.

Dictionary after updating multiple key-value : {'gfg': 4, 'is': 4, 'best': 4}

Time Complexity: O(n), where n is the length of the keys list. This is because the function needs to create a key-value pair for each key in the list, which takes constant time, and it needs to do this for each key in the list, which takes O(n) time in the worst case.

Space Complexity: O(n), because the recursive function calls itself n times, and each call creates a new dictionary with a single key-value pair. However, note that this is the worst-case space complexity because it assumes that each call to the function creates a new dictionary. In practice, the Python interpreter may optimize the function calls and reuse the same dictionary in memory, reducing the actual space usage.

Method#8: Using heapq:

Algorithm:

1. Initialize a list of keys and a value
2. Create a list of tuples with keys and value
3. Use the nsmallest function from heapq to get the smallest n elements from the tuple list
4. Convert the result to a dictionary using the dict() function
5. Print the resulting dictionary

Dictionary after Initializing multiple key-value : {'best': 4, 'gfg': 4, 'is': 4}

Time complexity: O(n log n), where n is the number of elements in the list of tuples. The nsmallest function uses a heap to find the smallest n elements, which takes O(n log n) time.

Space complexity: O(n), where n is the number of elements in the list of tuples. The nsmallest function creates a heap of size n. The resulting dictionary also has n key-value pairs.