Data transformation

Enables generation of a dictionary mapping distinct coordinate pairs to their product, skipping equal components.

Numerical simulations: need a lookup table of products for distinct parameter pairs; Game development: precompute score multipliers for different player positions; Data analysis: create a mapping of feature index pairs to combined metric while excluding identical indices.

Scientific computing scripts, data‑analysis notebooks, algorithm prototypes, educational examples.

{(first, second): first * second for first in first_iterable for second in second_iterable if first != second}

{(..., ...): ... for ... in ... for ... in ... if ... != ...}

first: hashable object, second: hashable object, first_iterable: iterable of hashable, second_iterable: iterable of hashable, condition: boolean expression (first != second)

• dict comprehension
• nested loops
• conditional filter

• Use explicit for‑loop with dict assignment – more verbose but easier to debug
• Use itertools.product with dict.update – flexible for many iterables
• Use list comprehension then dict() – adds an extra conversion step

Using a mutable object as a key → TypeError at runtime; Forgetting the parentheses around the key tuple → creates a set of keys instead of a dict; Reusing the same loop variable name in both for clauses → second loop overwrites first variable causing incorrect keys; Missing the colon after the key expression → SyntaxError; Omitting the if condition when it is required → diagonal entries appear unintentionally

List comprehension – produces a list instead of a dict; Set comprehension – produces a set of unique values; Nested for‑loops with dict.update – more imperative style; Dictionary literal with manual insertion – less concise

Coming from JavaScript: expecting object literal syntax without commas → Python dict comprehension requires commas between key and value and between items

• list comprehension
• set comprehension
• generator expression
• dict comprehension

Do not use when keys need to be mutable objects, as they are unhashable; Dict comprehensions are generally faster and more readable than building a dict with a loop, but for extremely large iterables they may increase memory pressure; If the iterables are generators, the comprehension consumes them lazily but the resulting dict holds all items in memory

Creates compact, efficient lookup tables that improve runtime performance of subsequent calculations and reduce boilerplate code

Think of the dict comprehension as a chessboard where each square stores the product of its coordinates, but the diagonal squares are left empty.

The key tuple must contain only hashable elements; otherwise a TypeError is raised when the dict is created

Nested dict comprehensions for multi‑level mappings, e.g., `{(a, b, c): f(a, b, c) for a in A for b in B for c in C}`