Data transformation

Generates a dictionary of even numbers to their squares, avoiding explicit loops and manual insertion.

Data processing: creating a lookup table of precomputed values; Algorithm implementation: mapping inputs to outputs for fast access; Educational examples: demonstrating concise Python syntax.

Python scripts, data‑analysis pipelines, algorithmic code, teaching materials, utility libraries.

{key: key**2 for key in range(limit) if key % 2 == 0}

{...: ... for ... in ... if ...}

key: int (even integer), limit: int (exclusive upper bound)

• range()
• if clause
• for loop
• dictionary literal
• comprehension

• Use a for‑loop with dict.update() for clearer step‑by‑step logic (more verbose)
• use dict(zip(...)) when keys and values are pre‑computed sequences (less flexible)
• use a generator expression with dict() for lazy evaluation (may be slower).

{"cause":"Using square brackets [] instead of curly braces {}","consequence":"Creates a list comprehension, not a dictionary, leading to a TypeError when expecting a dict."} {"cause":"Forgetting the if clause parentheses or using a single equals sign","consequence":"SyntaxError or unintended inclusion of odd numbers."} {"cause":"Using range(limit) without specifying an integer limit","consequence":"NameError or TypeError at runtime."} {"cause":"Attempting to assign to the key inside the comprehension (e.g., key = key**2)","consequence":"SyntaxError because assignment is not allowed in comprehensions."} {"cause":"Assuming the comprehension preserves order in Python <3.7","consequence":"Unexpected ordering of keys in older Python versions."}

List comprehension → produces a list, not a dict. Set comprehension → produces a set of unique values. Generator expression → yields items lazily, cannot be indexed directly.

Coming from JavaScript: you might try to use object literal syntax with commas inside a loop, which is invalid in Python → use dict comprehension with proper braces.

• comprehensions
• dictionary literals
• mapping constructions

Do not use this pattern when the key space is huge and memory consumption becomes a concern; the comprehension builds the entire dict in memory (O(n) space); for very large limits, consider a lazy mapping or database lookup instead.

Enables fast O(1) lookups of precomputed results, reduces code size, and improves readability, which helps prevent bugs from manual insertion errors.

Think of a dictionary comprehension as a factory line that instantly assembles a catalog of items as they roll off the production line.

Dictionary comprehensions were introduced in Python 2.7 and are fully supported in all Python 3 versions.

Use dictionary comprehension with a function or lambda to compute the value, enabling more complex transformations (e.g., {k: func(k) for k in iterable if cond(k)}).