Iterate over key-value pairs to process each element's components.

To express iteration over paired data, enabling simultaneous access to both components of each pair.

When you need to process each entry of a dictionary or a sequence of two-element tuples, such as when aggregating, transforming, or inspecting key-value data.

Inside loops for data processing, configuration handling, building dictionaries, iterating over zipped sequences, or any scenario where paired data is traversed.

for <key>, <value> in <iterable>:

for <key>, <value> in <iterable>:

<key> (variable for first element), <value> (variable for second element), <iterable> (any iterable yielding two-element tuples, e.g., dict.items(), list of tuples, zip(...))

• dict.items()
• list of tuples
• zip(...)
• enumerate(...) when paired
• list of pairs

• <key> and <value> can be any valid variable names (e.g.
• k
• v
• key
• val)
• <iterable> can be dict.items()
• list_of_pairs
• zip(keys
• values)
• etc.

Mismatching number of variables (e.g., using three variables for two-element tuples), forgetting the colon, using a non‑iterable, confusing with while loop, mistakenly using items() on non‑dict objects.

Similar: for item in iterable (single variable); Contrasting: while loop, list comprehension, enumerate loop with index and value.

Learners may confuse tuple unpacking with simple iteration, leading to ValueError when tuple lengths mismatch; may also confuse with dictionary key‑only iteration (for key in dict).

• iteration_constructs

Iteration order follows the iterable's order; for dicts, insertion order is preserved in Python 3.7+; using _ for ignored values is conventional.

Signals that the code will process each key‑value pair, making the intent to handle paired data explicit to readers.

Think 'for key, value in' when you need to examine both parts of a pair.

This construct is a fundamental Python idiom for traversing mappings or paired sequences; it combines iteration with tuple unpacking.

Can be extended to nested loops, comprehensions (e.g., {k: v*2 for k, v in pairs}), or combined with enumerate for indexed pairs.