Browse Chunks

Creates a new dictionary where each key from the given iterable is mapped to the same specified value. Useful for initializing lookup tables or setting default states.

dict.fromkeys(keys, value)

This pattern creates a new dictionary whose keys are the original values and whose values are the original keys. It solves the problem of needing a reverse lookup when the original mapping is one-to-one. You reach for it whenever you have a dictionary and you need to look up the original key by its associated value.

inverted = {value: key for key, value in source_dict.items()}

Updates a dictionary with key-value pairs from another dictionary, where each value is transformed (e.g., doubled) via a dictionary comprehension. This pattern merges transformed data into an existing dict in a single readable line.

target_dict.update({key: value_expr for key, val in source_dict.items()})

The chunk builds a list by iterating over an iterable and optionally filtering items based on a condition. It evaluates the expression for each selected item and collects the results into a new list. This is useful when you need a transformed collection without writing an explicit loop.

[expression for item in iterable if condition]

Produces a list of lengths of non-empty strings from the input list 'strings'.

[len(s) for s in strings if s]

This list comprehension builds a list of keys from a dictionary where the corresponding values are greater than zero. It provides a concise way to filter dictionary entries based on a numeric condition. Use it when you need the selected keys for further processing.

[key for key, value in dict_var.items() if value > 0]

Returns a list of (index, value) pairs for elements in `data` that are even and whose index is greater than 3. It combines enumeration, filtering, and tuple construction in a single readable expression.

[(index, value) for index, value in enumerate(iterable) if value % 2 == 0 and index > 3]

This list comprehension iterates over two iterables in parallel using zip, adds each pair of elements, and includes the result only when the first element is greater than a lower bound and the second element is less than an upper bound. It addresses the need for concise elementwise operations with filtering, eliminating the verbosity of explicit loops. Learners reach for it when they need to combine two sequences while applying simple conditional constraints.

[result for x, y in zip(iterable1, iterable2) if x > low and y < high]

Generates a list of products x*y where x and y are distinct integers from 1 to 5 and their sum is divisible by 3.

[expression for var1 in iterable1 for var2 in iterable2 if condition]

This list comprehension builds a new list by iterating over a sequence of numbers, selecting only those that are divisible by five. For each selected value it returns the value itself if it is non‑negative, otherwise it substitutes zero. It is useful when you need to filter and sanitise numeric data in a single, concise expression.

[item if item >= 0 else 0 for item in numbers if item % 5 == 0]

This dictionary comprehension builds a new dict by pairing each element from the iterable `keys` with the corresponding element from `values`. It solves the need to create a lookup table when data is stored in parallel sequences. Use it whenever you have two related sequences and need fast key‑based access.

{key: value for key, value in zip(keys, values)}

Creates a new dictionary containing only the entries from `mapping` whose values are positive, with each value doubled.

{k: v*2 for k, v in mapping.items() if v > 0}

This dictionary comprehension builds a mapping where each even integer in a given range is paired with its square. It eliminates the need for an explicit loop and intermediate assignments, reducing boilerplate. Use it whenever you need a quick lookup table of pre‑computed values.

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

Creates a new dictionary by applying `process` to each value in `raw` while excluding entries whose value is None.

{k: process(v) for k, v in raw.items() if v is not None}

The chunk creates a dictionary where each key is a tuple (first, second) and the value is the product of the two. It filters out pairs where the elements are equal, avoiding diagonal entries. It is useful when a lookup table of pairwise products is needed without self‑multiplication.

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

This chunk builds a new dictionary by iterating over the key‑value pairs of an existing mapping, doubling each value, keeping only those whose doubled value exceeds a threshold, and storing the original key with the doubled value incremented by one. It solves the pain point of having to write separate loops for transformation and filtering, allowing a compact, expressive one‑liner. It is triggered whenever a developer needs a filtered and adjusted view of a dictionary without mutating the original.

{key: transformed + 1 for key, val in source.items() if (transformed := val * 2) > limit}

Creates a set by evaluating an expression for each item in an iterable, automatically removing duplicates. Use when you need a unique collection of transformed values.

{expression for item in iterable}

Generates a set of squares of even numbers from 0 to 9.

{i*i for i in range(10) if i % 2 == 0}

The set comprehension builds a set of characters from a source string, keeping only those characters that are not in a specified exclusion set. It solves the problem of deduplicating and filtering characters in a single, concise expression. You reach for it when you need the unique, filtered elements of an iterable without preserving order.

{element for element in source_string if element not in excluded_chars}

Computes the length of each element in an iterable and collects the unique lengths into a set. This avoids dealing with duplicate lengths when you only care about distinct sizes. Use it when you need to know which lengths appear in a collection of strings or other items.

{len(item) for item in iterable}

Creates a set of computed values from an iterable, applying an expression to each item that satisfies a given condition. The set comprehension automatically deduplicates results.

{expr for item in iterable if condition}

A set comprehension that builds a set of 2‑tuples (x, y) by iterating over two ranges and keeping only the pairs where the first element is less than the second. It solves the need for a concise, memory‑efficient way to generate unique unordered pairs without writing explicit nested loops. You reach for it whenever you need all ordered pairs from a bounded integer domain that satisfy a simple relational condition.

{(a, b) for a in range(limit_a) for b in range(limit_b) if a < b}

This set comprehension builds a set of integers i where i ranges from 2 up to 49 and each i is not divisible by any integer d between 2 and the integer square root of i. In other words, it collects all prime numbers in that interval.

{item for item in range(start, end) if all(item % divisor != 0 for divisor in range(2, int(item**0.5) + 1))}

Creates a deque from a list and inserts an element at the left end.

from collections import deque; d = deque\[[^\]]*\]; d\.appendleft\([^)]*\)

Creates a Counter object that tallies hashable items, acting like a multiset. It simplifies counting occurrences in an iterable, removing the need for manual dictionary updates. Use it when you need to quickly compute frequencies of elements.

from collections import Counter; var = Counter(iterable)

Iterates over each element in an iterable, binding each element to the variable `item` for the duration of the loop body. This construct provides a clean way to perform an action for every element without manual index management.

for ; in ;:

Iterates over a sequence, yielding both the index and the value for each element. It eliminates the need for manual index management, reducing off‑by‑one errors. Use it whenever you need to know an element's position while processing its value.

for index, item in enumerate(sequence):

Iterates over key-value pairs in a mapping (e.g., dict) using the .items() method, binding each key and value to the specified variables. Allows simultaneous access to both keys and values without separate lookups, avoiding inefficient or error-prone key-only iteration. Used when processing mappings where both components are needed, such as filtering, transforming, or aggregating dictionary entries.

for <key>, <value> in <mapping>.items(): <body>

Iterates a fixed number of times using a throwaway loop variable.

for _ in range(<expression>):

Iterates over an iterable, unpacking each element so that all items except the last are collected into a list (head) and the final item is assigned to tail. This helps avoid manual indexing when the prefix and the final element need to be processed differently, reducing off‑by‑one errors. It is used when each item in the outer sequence is itself an iterable whose last component has a distinct role, such as a filename in a path or a label in a data row.

for *head, tail in iterable:

This chunk iterates over two sequences in parallel while also providing the current loop index. It solves the pain point of needing synchronized access to paired elements from two collections without manual index management. It is triggered when a developer has two related iterables (e.g., xs and ys) and wants to process each pair together with knowledge of their position.

for index, (elem1, elem2) in enumerate(zip(sequence1, sequence2)):

It iterates over a binary file object, repeatedly calling a lambda that reads a fixed‑size block until the sentinel value (empty bytes) is returned, thereby terminating the loop. This pattern eliminates the need for an explicit while‑loop with a break condition. It is typically used when processing large streams where loading the entire file into memory would be impractical.

for chunk in iter(lambda: file.read(chunk_size), sentinel):

A while loop repeatedly executes a block of code as long as a given condition evaluates to True. Use it when you need to repeat an action until a certain state changes.

while condition:

Increments a counter variable until it reaches a limit, executing the loop body each iteration. Use when you need to repeat an action a known number of times or until a condition changes.

while ; < ;: ; += 1

Runs an infinite loop that exits when a given condition becomes true; used for polling, waiting, or repeating an action until an external state changes.

while True: if ; break

Repeatedly executes do_work() while the condition 'not finished' evaluates to True, i.e., repeats the action until finished becomes True.

while not <condition>: <statement>

This snippet implements a retry loop that repeatedly calls an operation until it succeeds or a maximum number of attempts is reached. It addresses the pain point of transient failures that can be resolved by retrying the operation. It is triggered when an operation may raise a TemporaryError and you want to limit the number of retries.

while attempt < max_attempts: try: func() break except TemporaryError: attempt += 1

Reads binary data from a stream in chunks until an empty byte string signals end-of-stream, accumulating the chunks into a mutable buffer.

while (assignment_expression) != sentinel: block

The loop iterates over a sequence of numbers, checks a condition each iteration, and exits early with a break when the condition is met, otherwise performs an action such as printing. It addresses the need to stop processing once a target or sentinel value is encountered, avoiding unnecessary work. This pattern is triggered whenever a loop’s continuation depends on a runtime condition that may become true before the loop naturally finishes.

for index in range(limit): if condition: break action(index)

The loop iterates over a sequence and uses a `continue` statement to skip the rest of the current iteration when a condition is met. This avoids deep nesting by early‑exiting the loop body for unwanted items. It is used when you need to filter out specific elements while iterating.

for loop_var in range(range_arg): if condition: continue body_statement

Illustrates Python's for-else construct: the else block executes only when the loop finishes all iterations without encountering a break statement.

for <target> in <iterable>: <body> if <condition>: break else: <else_body>

The snippet counts down from a starting integer, decrementing each iteration, skipping even numbers via a continue, printing each remaining value, and finally printing a completion message after the loop finishes normally.

counter = start while counter > 0: counter -= step if counter % divisor == 0: continue print(counter) else: print(message)

This chunk manually iterates over an iterable using a while‑True loop with explicit calls to next() and StopIteration handling. It is useful when you need fine‑grained control over the iteration process or want to illustrate the iterator protocol for teaching purposes. You reach for it when demonstrating how a Python for‑loop works under the hood or when a for‑loop cannot be used directly.

while True: try: item = next(iterator) except StopIteration: break if condition: continue action else: else_action

The snippet iterates over two ranges with nested loops, breaking out of both loops as soon as the product of the indices exceeds a threshold. If no break occurs, the outer else clause triggers a fallback action. It is used to detect a condition early and handle the case where the condition never occurs.

for outer_var in range(outer_limit): for inner_var in range(inner_limit): if condition(outer_var, inner_var): break else: continue break else: fallback_action()

Iterates over a sequence of integers from 0 to 9 inclusive, executing the loop body once for each value.

for <variable> in range(<stop>):

Iterates over a sequence while providing both the index and the value of each item. Useful when you need to know the position of elements during iteration, such as for numbered output or conditional logic based on index.

for idx, val in enumerate(iterable):

Iterates over paired x and y coordinates from two sequences while providing an index for each pair.

for i, (x, y) in enumerate(zip(coords_x, coords_y)):

Iterates over fixed-size chunks of an iterable, grouping items into tuples of size n.

for <variable> in zip(*[iter(<iterable>)]*<chunk_size>):

The snippet iterates over a sequence in reverse order while simultaneously providing each element’s original index and value. It solves the pain point of needing to process items from the end toward the start without losing the original positional information. It is triggered when a developer must modify or reference elements based on their original indices while traversing backwards.

for index, item in reversed(list(enumerate(iterable))):

Iterates over the indices of a sequence in reverse order, from the last index down to 0.

for i in range(len(seq)-1, -1, -1):