Given a List, the task is to create a dictionary with only keys by using given list as keys. Let’s see the different methods we can do this task.
Method #1 : By iterating through list
Python3
# Python code to initialize a dictionary# with only keys from a list# List of keyskeyList = ["Paras", "Jain", "Cyware"]# initialize dictionaryd = {}# iterating through the elements of listfor i in keyList: d[i] = Noneprint(d) |
{'Cyware': None, 'Paras': None, 'Jain': None}
Time complexity: O(n), where n is the number of key-value pairs in the dictionary.
Auxiliary space: O(n), to store the keys and values in dictionary.
Method #2: Using dictionary comprehension
Python3
# Python code to initialize a dictionary# with only keys from a list# List of KeyskeyList = ["Paras", "Jain", "Cyware"]# Using Dictionary comprehensionmyDict = {key: None for key in keyList}print(myDict) |
{'Paras': None, 'Jain': None, 'Cyware': None}
Method #3 : Using zip() function
Python3
# Python code to initialize a dictionary# with only keys from a list# List of keyslistKeys = ["Paras", "Jain", "Cyware"]# using zip() function to create a dictionary# with keys and same length None valuedct = dict(zip(listKeys, [None]*len(listKeys)))# print dictprint(dct) |
{'Cyware': None, 'Paras': None, 'Jain': None}
Time Complexity: O(n), where n is the length of the listKeys list. The zip() function has a linear time complexity, and so does the dict() constructor.
Auxiliary Space: O(n), where n is the length of the listKeys list. We are creating a dictionary with n key-value pairs, where each value is None. The space complexity of the zip() function is also linear in the length of the input lists.
Method #4 : Using fromkeys() method
Python3
# Python code to initialize a dictionary# with only keys from a list# List of keysStudent = ["Paras", "Jain", "Cyware"]# using fromkeys() methodStudentDict = dict.fromkeys(Student, None)# printing dictionaryprint(StudentDict) |
{'Cyware': None, 'Jain': None, 'Paras': None}
The time complexity of the code is O(n), where n is the number of elements in the list ‘Student’.
The auxiliary space used by the code is O(n), where n is the number of elements in the list ‘Student’.
Method #5: Using the dict.__init__ method:
Here is another approach to creating a dictionary with only keys from a list, using the dict.__init__ method:
Python3
def create_dict(key_list): # Initialize an empty dictionary d = {} # Use the dict.__init__ method to add the keys from the input list to the dictionary d.__init__(zip(key_list, [None]*len(key_list))) return dkey_list = ["Paras", "Jain", "Cyware"]print(create_dict(key_list)) # {'Paras': None, 'Jain': None, 'Cyware': None}# This code is contributed by Edula Vinay Kumar Reddy |
{'Paras': None, 'Jain': None, 'Cyware': None}
This approach uses the dict.__init__ method to initialize the dictionary with the keys from the input list and None as the values.
The time complexity of the create_dict function is O(n), where n is the number of keys in the input list. This is because the function iterates through the input list once, and performs a constant number of operations on each iteration.
The space complexity of the create_dict function is also O(n), because the function creates a new dictionary with n keys. Additionally, the function creates a list of n None values to pass as the values for the keys in the dictionary.
Method#6: Using Recursive method.
This recursive function takes a list of keys as an argument and returns a dictionary with those keys as keys and None as values. It uses Python’s unpacking syntax (**) to merge the dictionary generated for the rest of the keys with the dictionary generated for the first key.
Python3
def initialize_dict(key_list): if len(key_list) == 0: return {} else: key = key_list[0] rest_keys = key_list[1:] return {key: None, **initialize_dict(rest_keys)}key_list = ["Paras", "Jain", "Cyware"]d = initialize_dict(key_list)print(d) |
{'Paras': None, 'Jain': None, 'Cyware': None}
Time complexity: O(n) – The function is called recursively once for each key in the list, so the time complexity is O(n), where n is the number of keys in the list.
Auxiliary Space O(n) – The maximum depth of the call stack is n, since the function is called recursively once for each key in the list, so the space complexity is also O(n). Additionally, we create a dictionary with n keys and n values, so the total space complexity is O(n).
