Dictionary comprehensions are a concise and efficient way to create dictionaries in Python. They allow you to quickly generate dictionaries that conform to specific rules with just one line of code. If you’re familiar with list comprehensions, understanding dictionary comprehensions will be very straightforward, as their syntax is similar—they just generate key-value pairs instead of individual elements.
1. Why Use Dictionary Comprehensions?¶
Before introducing comprehensions, let’s review the traditional way of creating a dictionary. For example, to generate a dictionary containing the squares of numbers from 1 to 5:
# Traditional method: Initialize an empty dictionary and assign values in a loop
squares = {}
for num in range(1, 6):
squares[num] = num **2
print(squares) # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
This approach requires several lines of code, which can become cumbersome if the data volume is large or the rules are complex. Dictionary comprehensions can compress this process into a single line, making the code much cleaner.
2. Basic Syntax of Dictionary Comprehensions¶
The core structure of a dictionary comprehension is:
{key_expression: value_expression for variable in iterable [if condition_expression]}
- Key Expression: Generates the “keys” of the dictionary. It can be a variable, a function call, or an operation result.
- Value Expression: Generates the “values” of the dictionary. It can also be a variable, a function call, or an operation result.
- Iterable: An object that can be iterated over, such as a list, tuple, or
range. - Condition Expression (optional): Filters elements to be included; elements that do not meet the condition are excluded.
3. Starting with Simple Examples¶
Example 1: Generate Simple Key-Value Pairs¶
Suppose we have a list ['a', 'b', 'c'] and want to create a dictionary where the keys are the list elements and the values are 0:
keys = ['a', 'b', 'c']
result = {key: 0 for key in keys}
print(result) # Output: {'a': 0, 'b': 0, 'c': 0}
Here, key is the loop variable, and key: 0 is the key-value pair expression. The list keys is iterated over to generate each key-value pair.
Example 2: Values as Calculation Results¶
If the values need to be the square of the keys (e.g., 1:1, 2:4), simply modify the value expression:
numbers = [1, 2, 3, 4]
squares = {num: num** 2 for num in numbers}
print(squares) # Output: {1: 1, 2: 4, 3: 9, 4: 16}
Here, num **2 is the value calculation, generating the square of each number as the value.
Example 3: With Conditional Filtering¶
If you only want to retain key-value pairs that meet a condition (e.g., only even keys):
numbers = [1, 2, 3, 4, 5, 6]
even_squares = {num: num** 2 for num in numbers if num % 2 == 0}
print(even_squares) # Output: {2: 4, 4: 16, 6: 36}
The condition if num % 2 == 0 filters out odd numbers, retaining only the even keys and their squares.
4. Advanced: Generating Dictionaries from Other Iterables¶
Dictionary comprehensions can generate dictionaries not only from lists but also from tuples, range, etc. For example:
# Generate a dictionary from a tuple
items = (('name', 'Alice'), ('age', 25), ('city', 'Beijing'))
person = {k: v for k, v in items}
print(person) # Output: {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
# Generate a dictionary from range (keys 1-5, values are cubes of keys)
cubes = {num: num **3 for num in range(1, 6)}
print(cubes) # Output: {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
5. Note: Distinguish Between Different Comprehensions¶
Beginners often confuse three types of comprehensions:
- List Comprehension: [expression for variable in iterable] (result is a list)
- Dictionary Comprehension: {key: value for variable in iterable} (result is a dictionary)
- Set Comprehension: {expression for variable in iterable} (result is a set, with no duplicate elements)
For example:
# List comprehension
print([num for num in range(1, 4)]) # [1, 2, 3]
# Dictionary comprehension
print({num: num**2 for num in range(1, 4)}) # {1: 1, 2: 4, 3: 9}
# Set comprehension
print({num**2 for num in range(1, 4)}) # {1, 4, 9}
6. Summary: Advantages of Dictionary Comprehensions¶
- Conciseness: A single line of code handles complex logic, avoiding repetitive loops and assignments.
- Readability: Directly expresses the “key-value pair generation rule,” making it more intuitive than traditional loops.
- Efficiency: Internally optimized, it is more efficient than manual loops (especially with large datasets).
Dictionary comprehensions are a powerful tool for creating dictionaries in Python. Mastering them will make your code cleaner and more professional. Beginners are advised to practice generating dictionaries from simple lists first, then gradually try scenarios with conditional filtering and complex expressions—you’ll quickly become proficient!