> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Dictionary Comprehension
Dictionary comprehension is a declarative construct in Python that provides a concise syntax for generating a new dictionary by applying an expression to each item within an existing iterable. It evaluates a key-value pair expression during iteration, optionally filtering elements via conditional statements, and constructs the resulting dictionary object in memory.
## Base Syntax
The standard syntax utilizes curly braces `{}` containing key and value expressions separated by a colon `:` to define a key-value pair, followed by a `for` clause.
```python theme={"dark"}
squares = {x: x**2 for x in range(6) if x % 2 == 0}
print(squares)
# Output: {0: 0, 2: 4, 4: 16}
```
## Component Breakdown
Using the example above, the comprehension consists of the following components:
* **Key Expression (`x`)**: The expression evaluated to produce the dictionary key. The resulting value must be of a hashable type (e.g., strings, integers, or tuples, provided all of their contained elements are also hashable).
* **Value Expression (`x**2`)**: The expression evaluated to produce the dictionary value. This can be any valid Python object or expression.
* **Iteration Clause (`for x in range(6)`)**: The primary iteration clause. It yields elements from the source iterable, binding them to the local variable.
* **Condition (`if x % 2 == 0`)** *(Optional)*: A predicate evaluated for each item. If the condition evaluates to `False`, the current iteration is skipped, and no key-value pair is added to the dictionary.
## Advanced Syntax Variations
### Conditional Expressions (Ternary Operators)
While the trailing `if` acts as a filter, you can use Python's ternary operator within the value expression (or key expression) to dynamically alter the output based on a condition without filtering the item out entirely.
```python theme={"dark"}
parity = {x: ("even" if x % 2 == 0 else "odd") for x in range(3)}
print(parity)
# Output: {0: 'even', 1: 'odd', 2: 'even'}
```
### Nested Iteration
Dictionary comprehensions support multiple `for` clauses. The evaluation order is strictly left-to-right, mirroring the structure of nested standard `for` loops.
```python theme={"dark"}
matrix_coords = {(row, col): 0 for row in range(2) for col in range(2)}
print(matrix_coords)
# Output: {(0, 0): 0, (0, 1): 0, (1, 0): 0, (1, 1): 0}
```
## Technical Characteristics
* **Variable Scope:** In Python 3, the iteration variables are strictly scoped to the comprehension block. They do not leak into or overwrite variables in the enclosing namespace.
* **Key Overwriting:** If the key expression generates duplicate keys during the iteration process, the dictionary enforces key uniqueness by retaining only the value from the *last* evaluated expression for that specific key.
```python theme={"dark"}
duplicates = {x % 2: x for x in range(4)}
print(duplicates)
# Output: {0: 2, 1: 3}
```
* **Bytecode Optimization:** Dictionary comprehensions are generally more performant than equivalent `for` loops utilizing `dict[key] = value` assignments. The Python interpreter optimizes comprehensions at the bytecode level by utilizing the `MAP_ADD` opcode to populate the dictionary directly on the stack. This avoids the overhead of repeated `LOAD_FAST` instructions required to load the dictionary reference during each iteration of a standard loop, which relies on the `STORE_SUBSCR` opcode.
* **Memory Allocation:** Dictionary comprehensions eagerly evaluate the iterable and construct the entire dictionary object in memory at once. Consequently, processing extremely large iterables will result in high memory consumption proportional to the number of generated key-value pairs. Note that passing a generator expression to the `dict()` constructor (e.g., `dict((k, v) for k, v in iterable)`) does not mitigate this memory footprint, as the constructor still immediately consumes the entire generator to build the complete dictionary in memory.
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
