Python dict() Function

Spread the love

The dict() function is a built-in Python function used primarily for dictionary creation. While dictionaries can be created using curly braces {}, the dict() function offers a more programmatic and sometimes more readable approach to dictionary initialization.

Syntax and Parameters

The generic syntax for the dict() function is:

dict(mapping, **kwarg)
dict(iterable, **kwarg)


  • kwarg: You can pass keyword arguments to dict(). It will then create a dictionary with the passed keywords as keys and their respective values as dictionary values.
  • mapping: A mapping object (like another dictionary).
  • iterable: An iterable producing pairs, which can be converted into dictionary keys and values.


Creating an Empty Dictionary:

Dictionaries are central data structures in Python, primarily used to store data in a key-value pair format. An empty dictionary is a dictionary with no key-value pairs in it. There are a few ways to create an empty dictionary, and the dict() function is one of them.

Using the dict( ) Function:

The dict() function, without any arguments, returns a new dictionary that’s devoid of any content.

empty_dict = dict()
print(empty_dict)  # Outputs: {}

In the above code:

  1. We invoke the dict() function without any parameters. This returns an empty dictionary.
  2. We assign this empty dictionary to the variable empty_dict.
  3. When we print empty_dict, it displays {}, the representation of an empty dictionary in Python.

Creating a Dictionary Using Keyword Arguments:

The dict() function in Python is multi-faceted. While its primary purpose is to create dictionaries, it provides a unique approach to do so using keyword arguments. Essentially, keyword arguments allow you to directly specify the keys and values of the dictionary during its creation.


dict_name = dict(key1=value1, key2=value2, ...)

In the syntax above:

  • key1, key2, etc., are the dictionary keys.
  • value1, value2, etc., are the respective values for the provided keys.

The keys in this context are the argument names themselves, and they must be valid Python identifiers. The values are the values assigned to these arguments.


Consider we want to create a dictionary that stores information about a book, including its title, author, and publication year:

book_info = dict(title="To Kill a Mockingbird", author="Harper Lee", year=1960)
# Outputs: {'title': 'To Kill a Mockingbird', 'author': 'Harper Lee', 'year': 1960}

In the example above:

  1. We invoke the dict() function.
  2. We pass three keyword arguments: title, author, and year. These become the keys of our dictionary.
  3. The values “To Kill a Mockingbird”, “Harper Lee”, and 1960 are associated with their respective keys.
  4. The created dictionary is assigned to the variable book_info.

Creating a Dictionary Using a Mapping:

The term “mapping” in the context of Python typically refers to collections of key-value pairs. The most common mapping type in Python is, in fact, the dictionary itself. Therefore, when we talk about creating a dictionary from a mapping, we’re often discussing the creation of a new dictionary that is a copy of an existing dictionary or a dictionary-like object.


new_dict = dict(existing_mapping)

In the syntax above, existing_mapping is a dictionary or another object that supports the mapping protocol (i.e., it has key-value pairs).


Imagine you have an existing dictionary that represents a person’s contact details:

existing_contact = {
    'name': 'Jane Doe',
    'email': '',
    'phone': '123-456-7890'

# Create a new dictionary using the existing dictionary
new_contact = dict(existing_contact)

# Outputs: {'name': 'Jane Doe', 'email': '', 'phone': '123-456-7890'}

In the example above:

  1. We have an existing_contact dictionary with three key-value pairs.
  2. We create a new_contact dictionary by passing the existing_contact dictionary to the dict() function.
  3. This results in a new dictionary that’s a copy of the original one. It’s worth noting that this is a shallow copy (the top-level container is duplicated, but the copy is still populated with references to the same items as the original dictionary).

Points to Remember:

  • Shallow Copy: When you create a dictionary from an existing dictionary using dict(), it’s a shallow copy. This means that while the dictionaries themselves are different objects, the items inside (if they are complex objects like lists or other dictionaries) still reference the same memory locations. If mutability is a concern, you might need to look into deeper copying mechanisms, like the copy module’s deepcopy function.
  • Key-Value Integrity: The source mapping must strictly adhere to the key-value structure. If there’s an element in the source that isn’t a two-item sequence (like a key-value pair), a TypeError will be raised.

Creating a Dictionary Using an Iterable:

Python’s dict() function can also accept an iterable that yields pairs of items, typically in the form of tuples, where the first item of each pair becomes a key and the second item becomes the associated value in the dictionary. This method offers flexibility, especially when working with functions or data structures that produce or operate on sequences.


new_dict = dict(iterable_of_pairs)

Here, iterable_of_pairs should yield pairs of items, such as two-element lists or tuples.


Let’s illustrate this using a list of tuples:

# A list of tuples where each tuple has 2 items
list_of_pairs = [("name", "John"), ("age", 30), ("city", "New York")]

# Convert the list of tuples into a dictionary
person_info = dict(list_of_pairs)

# Outputs: {'name': 'John', 'age': 30, 'city': 'New York'}

In the example above:

  1. We start with a list_of_pairs where each tuple inside the list represents a key-value pair.
  2. We pass this list to the dict() function to create the person_info dictionary.
  3. The resulting dictionary takes the first item of each tuple as a key and the second item as its value.

Potential Sources of Iterables:

Functions Producing Pairs: Functions like zip() can be used to produce pairs from separate lists of keys and values. For example:

keys = ["name", "age", "city"]
values = ["John", 30, "New York"]

person_info = dict(zip(keys, values))
print(person_info)  # Outputs: {'name': 'John', 'age': 30, 'city': 'New York'}

Here, the zip() function pairs each element from keys with the corresponding element from values, forming tuples. The dict() function then turns these tuples into dictionary key-value pairs.

Parsing Data: When processing data from sources like text files or databases, it’s common to encounter data in pairs. After extracting and structuring this data into pairs using various methods, the dict() function can then help in turning them into dictionaries.

Points to Consider:

Pair Integrity: It’s essential that the iterable provides pairs of items. If any element in the iterable is not a pair (e.g., it has more or fewer than two items), a ValueError will be raised.

Unique Keys: If the iterable provides multiple pairs with the same key, the last pair with that key will determine the value in the dictionary. Earlier pairs with that key will be overwritten.

list_of_pairs = [("color", "red"), ("color", "blue")]
color_info = dict(list_of_pairs)
print(color_info)  # Outputs: {'color': 'blue'}

In this example, even though “red” is first associated with “color”, it gets overwritten by “blue”.

Creating dictionaries from iterables using the dict() function provides a powerful way to construct dictionaries programmatically, especially when dealing with data in sequences or when combining separate sequences of keys and values.


Python’s dict() function offers a versatile method to create dictionaries, whether from scratch, from other mappings, or from iterables. Dictionaries themselves are a cornerstone of Python programming, often preferred for their performance characteristics and readability. By mastering the dict() function and dictionaries as a whole, developers can wield a significant chunk of Python’s power in data manipulation and representation.

Leave a Reply