How to Initialize Dictionary in Python

Dictionaries are an essential data structure in Python that lets you save data as key-value pairs. These key-value pairs make it easy to search and manage data. Python users often need to create and initialize dictionaries when working on tasks like managing settings, processing data, or building algorithms. For this purpose, several methods are used in Python, such as dict() constructor, dict.fromkeys(), dictionary comprehension, etc.

In this tutorial, we explore the different ways to initialize a dictionary in Python, best practices to follow, and recommendations for efficient usage.

What is a Dictionary in Python?

A dictionary in Python is an unordered, mutable collection of items. Each item in a dictionary consists of a key and its associated value. Keys must be unique and immutable (e.g., strings, numbers, or tuples), while values can be of any data type and can be duplicated.

Initializing a Dictionary in Python

Let’s explore the following methods to understand how to initialize a dictionary in Python. Before proceeding, we assume that Python is installed on your Windows 10 system, along with a code editor like Visual Studio Code, Thonny, or PyCharm, for efficient coding.

Method 1: Passing Key-Value Pairs as Literals

This is the simplest way to create a dictionary. You directly provide the key-value pairs inside curly braces. This method is useful when you know the exact data to include in the dictionary:

authors = {"name": "Anees", "age": 25}
print (authors)

Here, name and age are keys, while Anees and 25 are their respective values:

Method 2: Using dict() Constructor

To create a dictionary in Python, you can pass key-value pairs as keyword arguments to the dict() function. This method is useful for quick initialization when the keys are valid Python identifiers:

authors =  dict(name="Anees Asghar", age=25)
print (authors)

This built-in method creates a dictionary and initializes it with the specified values:

Method 3: Initializing Dictionary via Lists

You can initialize a dictionary in Python using a list of tuples. Each tuple must represent a key-value pair, where the first element is the key and the second element is the value. This method is useful when the key-value pairs are dynamically generated or fetched from another source:

authors = [("name", "Anees"), ("age", 25)]
result = dict(authors)
print(result)

The dict() function is used to initialize a dictionary from the list of tuple authors. Each tuple in the list is converted into a key-value pair in the dictionary:

Method 4: Using Tuples

You can also initialize a dictionary with a tuple of tuples. This method is ideal when data is already organized as immutable tuples:

authors = (("name", "Anees"), ("age", 25))
result = dict(authors)
print(result)

The output confirms that a dictionary has been successfully initialized using tuples:

Method 5: Using Dictionary Comprehension

Dictionary comprehension is a compact way to construct dictionaries dynamically. This method is useful when you need to create dictionaries programmatically, especially for large datasets:

squared_numbers = {x: x**2 for x in range(5)}
print(squared_numbers)

This code creates a dictionary where the keys are numbers from 0 to 4, and the values are their squares:

Method 6: Using dict.fromkeys()

The fromkeys() method initializes a dictionary with a set of keys and assigns the same value to all of them. It is useful for initializing a dictionary with default values:

dictKeys = ["name", "age", "city"]
dictionary = dict.fromkeys(dictKeys, None)
print(dictionary)

This code creates dictionary and initializes all its values with a default entry “None”:

Method 7: Using Dictionary Comprehension with zip()

You can use zip() to combine two lists (keys and values) and create a dictionary. This method is handy when keys and values are stored in separate lists:

dictKeys = ["name", "age"]
dictValues = ["Anees", 25]
my_dict = {k: v for k, v in zip(keys, values)}

In this example, the zip() function combines the two lists into pairs, and the dictionary comprehension creates a dictionary by using the elements from these pairs as keys and values:

Method 8: Using a Generator Expression

You can also use a generator expression to initialize a dictionary. This is an efficient method for creating large dictionaries without storing intermediate data:

dictData = ((x, x**2) for x in range(5))
my_dict = dict(dictData)
print(my_dict)

It creates a dictionary where the keys are numbers from 0 to 4, and the values are their squares using a generator expression:

Method 9: Using a Loop

You can use a loop to initialize a dictionary when the data isn’t available all at once. This approach is useful when dictionary initialization depends on conditions or iterative processes:

newDict = {}
for i in range(5):
    newDict[i] = i**2
print(newDict)

In this code, the for loop iterates over the range from 0 to 4. For each iteration, it adds a key-value pair to the newDict, where the key is i, and the value is the square of i:

Initializing an Empty Dictionary

To create an empty dictionary in Python, either you can use curly braces or dict() constructor, as shown below:

dictionary1 = {}
print(dictionary1)
dictionary2 = dict()
print(dictionary2)

The output shows that both these methods successfully create an empty dictionary:

After this, you can add items to the dictionary as needed. 

Best Practices for Initializing Dictionaries

Here are some best practices to follow when initializing dictionaries in Python:

1. Select the method that best fits your use case to ensure code clarity and efficiency.
2. Use built-in functions like dict() and fromkeys() to avoid redundant code.
3. Use comprehension for large data as it is concise and often more efficient for programmatically generating dictionaries.
4. Make sure the keys are immutable to avoid runtime errors.

Conclusion

Python provides multiple ways to initialize dictionaries. These methods include dict() constructor, tuples, lists, dict.fromkeys(), etc. You can choose any of these methods depending on your needs. If you know the dictionary’s structure in advance, initializing with literals or the dict() constructor is the simplest and most readable approach. For dynamic dictionaries, dictionary comprehension is the recommended method for its clarity and efficiency. In this article, we discussed all these methods with appropriate examples.

FAQ