Python dict Function

Last modified April 11, 2025

This comprehensive guide explores Python’s dict function, which creates dictionary objects. We’ll cover creation methods, manipulation techniques, and practical examples of using dictionaries.

Basic Definitions

The dict function creates a new dictionary object. Dictionaries are mutable mappings from keys to values. They are unordered (Python 3.7+ preserves insertion order), and keys must be hashable.

Key characteristics: fast lookups by key, mutable, can be nested, and support various creation methods. Dictionaries are fundamental Python data structures.

Creating Empty Dictionary

The simplest way to create an empty dictionary is by calling dict() without arguments. This is equivalent to using empty curly braces.

empty_dict.py

Create empty dictionary

empty1 = dict() empty2 = {}

print(empty1) # {} print(empty2) # {} print(type(empty1)) # <class ‘dict’> print(empty1 == empty2) # True

Both methods create identical empty dictionary objects. The dict() constructor is more explicit while {} is more concise.

This example shows type checking and equality comparison between the two creation methods. They produce equivalent results.

Creating Dictionary from Key-Value Pairs

You can create a dictionary by passing keyword arguments to dict(). Each argument becomes a key-value pair in the dictionary.

kw_dict.py

Create dictionary with keyword arguments

person = dict(name=‘John’, age=30, city=‘New York’)

print(person) # {’name’: ‘John’, ‘age’: 30, ‘city’: ‘New York’} print(person[‘age’]) # 30

Keys must be valid Python identifiers

config = dict(max_connections=100, timeout=30) print(config[’timeout’]) # 30

This method is clean for creating dictionaries with string keys that are valid Python identifiers. The keys don’t need quotes in this syntax.

Note that this approach won’t work for keys that aren’t valid Python variable names (like strings with spaces).

Creating Dictionary from Iterable of Pairs

dict() can create a dictionary from an iterable of key-value pairs. Each pair is typically a tuple or list with exactly two elements.

iterable_dict.py

From list of tuples

pairs = [(‘a’, 1), (‘b’, 2), (‘c’, 3)] mapping = dict(pairs)

print(mapping) # {‘a’: 1, ‘b’: 2, ‘c’: 3}

From list of lists

matrix_coords = [[‘x’, 10], [‘y’, 20], [‘z’, 30]] coord_dict = dict(matrix_coords)

print(coord_dict[‘y’]) # 20

This method is useful when you have existing sequences of pairs that you want to convert to a dictionary. The pairs can be any two-element iterables.

This approach is commonly used with zip() to create dictionaries from separate lists of keys and values.

Creating Dictionary from Two Iterables

By combining dict() with zip(), you can create a dictionary from two separate iterables (one for keys, one for values).

zip_dict.py

From two lists

keys = [’name’, ‘age’, ‘job’] values = [‘Alice’, 25, ‘Engineer’]

person = dict(zip(keys, values)) print(person) # {’name’: ‘Alice’, ‘age’: 25, ‘job’: ‘Engineer’}

From strings

headers = [‘Content-Type’, ‘Content-Length’, ‘Server’] defaults = [’text/html’, 0, ‘Apache’]

config = dict(zip(headers, defaults)) print(config[‘Server’]) # ‘Apache’

This pattern is extremely useful when you have related sequences that should be combined into key-value pairs. The zip() function pairs elements by position.

The resulting dictionary will have length equal to the shortest input iterable. No error occurs if lengths differ.

Dictionary Comprehension

While not directly using the dict() function, dictionary comprehensions are a powerful way to create dictionaries from any iterable.

dict_comprehension.py

Create dictionary from range

squares = {x: x*x for x in range(6)} print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Create dictionary with condition

even_squares = {x: x*x for x in range(10) if x % 2 == 0} print(even_squares) # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

Transform existing dictionary

prices = {‘apple’: 0.5, ‘banana’: 0.25, ‘orange’: 0.75} sale_prices = {k: v*0.9 for k, v in prices.items()} print(sale_prices[‘apple’]) # 0.45

Dictionary comprehensions offer a concise way to create dictionaries. They follow the pattern {key_expr: value_expr for item in iterable}.

They can include conditions and transform existing dictionaries, making them very flexible for data processing tasks.

Best Practices

• Choose appropriate creation method: Use the most readable approach for your data

• Prefer dict() for empty dictionaries: More explicit than {}

• Use keyword args for simple cases: When keys are valid identifiers

• Use zip() for parallel sequences: When you have separate key and value lists

• Consider comprehensions: For transformations and filtered creations

Source References

• Python dict Documentation

• Python Dictionaries Tutorial

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.