Browse Chunks

Creates a list containing each number from 0 to 4 multiplied by 2.

[expression for item in iterable]

A set comprehension builds a set by evaluating an expression for each element of an iterable and including the result only when a predicate is true. It eliminates the need for separate loops and explicit add calls, reducing boilerplate and the risk of forgetting to add items. Use it whenever you need a collection of unique values that satisfy a filter.

{item for item in iterable if condition}

This chunk creates a new dictionary where each value from the original dictionary is multiplied by 2. It avoids the need to write an explicit loop to transform dictionary values. Use this when you have a dictionary of numeric values and want to produce a new dictionary with each value scaled by a factor of 2.

{key: value * 2 for key, value in source_dict.items()}

Generates a list of tuples representing the Cartesian product of two ranges: i from 0 to 2, j from 0 to 1.

[(i, j) for i in range(A) for j in range(B)]

Generates a list of the squares of integers from 1 to 5.

[i*i for i in range(start, stop+1)]

Computes the set of unique string lengths from an iterable of strings.

{len(item) for item in iterable}

Creates a new dictionary with keys and values swapped from the given dictionary.

{v:k for k,v in <iterable>.items()}

Producescription: "Produces a list of integers from 0 to 19 that are divisible by both 2 and 5 (i.e., multiples of 10).", "primary_function":"Filter a range of integers using a conjunction of two modulo conditions within a list comprehension." ,"communicative_purpose":"Express a concise filter for numbers meeting multiple criteria." ,"trigger_situations":"When needing to select numbers satisfying multiple modulus conditions from a range or iterable." ,"contexts":"Data filtering, numeric processing, interview coding exercises, teaching list comprehensions." ,"output_priority":"medium" ,"frequency":"common" ,"formulaicity":"high" ,"construction_type":"list comprehension" ,"acquisition_priority":"intermediate" ,"pattern":"[x for x in iterable if condition1 and condition2]" ,"core_structure":"[ expression for item in iterable if condition ]" ,"substitution_slots":"expression: x ; iterable: range(20) ; condition: x%2==0 and x%5==0" ,"typical_collocates":"range, for, in, if, and, %, ==" ,"common_substitutions":"replace range(20) with other iterables; change conditions to other predicates; replace expression with a function call or transformation." ,"variations":"use 'or' instead of 'and'; change modulo divisor; apply a transformation like x*2; use filter() or a generator expression." ,"common_mistakes":"using bitwise '&' instead of 'and'; misplacing parentheses; forgetting to close brackets; confusing modulo precedence." ,"similar_contrasting":"Similar: [x for x in range(20) if x%10==0]; Contrast: filter(lambda x: x%2==0 and x%5==0, range(20)) or an explicit for‑loop with append." ,"interference_warnings":"Confusing bitwise '&' with logical 'and'; assuming modulo has lower precedence than 'and'; omitting the second condition." ,"nuance":"Both conditions must be true; due to short‑circuit evaluation the second condition is skipped if the first is false; 0 is included because 0 % n == 0 for any n." ,"pragmatic_effect":"Concisely communicates a multi‑condition filter, signalling the intent to select numbers that satisfy all given criteria." ,"note":"Includes 0 because 0 % n == 0 for any n." ,"recall_cue":"Numbers divisible by both 2 and 5 up to 20." ,"spacing_tag":"medium" ,"upgrade_path":"Consider using filter() with a lambda or itertools.filterfalse for reusable predicates, or a single combined condition (x%10==0) for simplicity." ,"chunk_family":"list comprehension filters" ,"register":"technical" ,"type_label":"list comprehension pattern" ,"semantic_transparency":"transparent" ,"discourse_function":"referential"} {

[result for item in iterable if condition1 and condition2]

This comprehension builds a list of three-element tuples containing the outer index, the inner index, and their product. It is useful when you need to generate combinatorial data limited to even outer indices. You reach for it when a compact expression replaces nested loops with a conditional filter.

[(index_i, index_j, index_i * index_j) for index_i in range() for index_j in range(index_i + 1) if index_i % 2 == 0]

Returns the set of unique character counts for each string longer than five characters in the given list.

{len(set(s)) for s in iterable if condition}

It builds a new dictionary by iterating over an existing mapping and replacing each value with itself if it is positive, otherwise with zero. This helps clamp negative numbers to zero without needing separate loops or helper functions. Use it when you need to sanitize numeric data that may contain invalid negative entries before further processing.

{key: (value if value > 0 else 0) for key, value in dict_expr.items()}

The comprehension builds a list by iterating over a range, computing a value for each element, and including it only if it satisfies a condition. It addresses the need to both calculate and filter in a single, concise expression, avoiding separate loops and temporary variables. It is used when you want to generate a filtered collection of derived values directly from an iterable.

[result for var in iterable if (result := expr) condition]

A generator expression creates an iterator that yields items one at a time from an underlying iterable. It avoids building an intermediate list, which saves memory and can improve performance for large data streams. Use it when you need a lazy sequence that will be consumed by functions like sum, any, or in a for‑loop.

(... for ... in ...)

A generator expression that lazily yields the square of each element from the iterable data.

(expression for variable in iterable)

A generator expression that lazily yields elements from an iterable `data` that satisfy the condition `x % 2 == 0` (even numbers). It produces an iterator without building an intermediate list, useful for memory‑efficient filtering.

(item for item in iterable if condition)

Defines a generator function that delegates iteration to another iterable using yield from, producing values from that iterable without manually looping. This pattern simplifies creating lazy wrappers around existing sequences.

def function_name(): yield from iterable

This pattern creates a generator expression that yields the product of two loop variables, iterating over nested ranges. It is used when you need to lazily compute values from a Cartesian product without building an intermediate list.

(expression for var1 in iterable1 for var2 in iterable2)

This generator expression yields (index, value) pairs for each truthy element in a collection, preserving the original order. It helps when you need to process items together with their positions while skipping falsy values. You reach for it when iterating over large sequences where memory efficiency and conditional filtering are required.

((index, value) for index, value in enumerate(collection) if value)

The expression creates a generator that yields normalized values for each raw element in a collection, discarding any items where the normalization returns None. It uses the assignment expression (walrus operator) to compute the normalized value once per iteration and immediately test its validity. This pattern is useful when a preprocessing step may fail for some inputs and you want to filter out those failures without extra loops.

(norm for raw_item in data_collection if (norm := normalize(raw_item)) is not None)

The function `gen` is a generator that iterates over the numbers 0 through 19 and yields only those divisible by three. It provides a memory‑efficient way to produce a filtered sequence without building an intermediate list. Use it when you need to process or stream specific items from a range lazily.

def generator_name(): for index in range(limit): if index % divisor == 0: yield index

Returns an iterator yielding (index, value) pairs for every fourth element of `data`, using 1‑based indexing.

(idx, val) for idx, val in enumerate(data, start=1) if idx % 4 == 0

The iter() function returns an iterator object for any given iterable, allowing element‑by‑element access without materializing a full list. It addresses the need for memory‑efficient traversal when dealing with large or infinite sequences. Use it whenever you need a lazy, consumable view of a collection, such as before calling next() or feeding into functions that expect an iterator.

iter(iterable)

The `next()` function retrieves the subsequent element from an iterator object. It addresses the need to consume items lazily without loading the entire collection into memory, which is especially useful for large or infinite streams. You reach for it when you have an iterator and you need the next value, optionally providing a default to avoid a StopIteration exception.

next(iterable, fallback)

This chunk iterates over each element of a collection by obtaining an iterator with iter() and looping with a for statement. It addresses the need to process items sequentially without manually managing index counters or risking off‑by‑one errors. You reach for it whenever you have an iterable (list, tuple, generator) and want to execute code for every element.

for element in iter(iterable):

This pattern manually pulls the next element from an iterator inside a try block and exits the surrounding loop when a StopIteration exception is raised. It solves the pain point of needing fine‑grained control over iteration when a simple for‑loop cannot express additional per‑iteration logic. It is triggered whenever code iterates over a custom iterator or generator and must break out cleanly at exhaustion.

try: item = next(iterator) except StopIteration: break

This pattern manually iterates over an iterator by repeatedly calling next() inside a try block, catching StopIteration to break the loop. It mimics the behavior of a for loop but gives explicit control over iteration.

while True: try: ; = next(; ) except StopIteration: break

This chunk reads a file object `f` in fixed-size blocks of 4096 bytes using an iterator with a sentinel value of empty bytes. Each block is assigned to `chunk` and passed to `process(chunk)`. It solves the problem of processing large files incrementally without loading the entire file into memory, and is used whenever you need to stream data until end‑of‑file.

for chunk in iter(lambda: file_obj.read(block_size), sentinel): process_func(chunk)

This pattern creates an iterator from a sequence, extracts the first element with next(), and then materializes the remaining items into a list. It solves the pain point of needing a head‑tail split without requiring the original object to support slicing. It is triggered when you have any iterable and must treat the first item specially while still accessing the rest.

it = iter(iterable); first = next(it); rest = list(it)

The literal "Hello\nWorld" produces a string containing a line break between "Hello" and "World". It is used when a fixed multi-line message is needed without constructing it dynamically. It is typically employed when a programmer wants to embed a newline directly in source code.

"Hello\nWorld"

A raw string literal prefixed with 'r' treats backslashes as literal characters, useful for Windows file paths, regular expressions, or any string containing many backslashes.

r"raw_content"

Python f-string literal that embeds expressions inside string literals for concise formatting.

f"Value: {;}"

This chunk is a string literal that contains a tab character before and after the word "Tab". It is used to embed literal tab characters in source code for formatting output. It is appropriate when you need to produce tab‑separated text or align columns in console output.

"\tTab\t"

The chunk calls the built‑in string method upper() to produce a new string where all alphabetic characters are converted to their uppercase equivalents. It addresses the need to normalise text case, which can cause mismatches in comparisons or inconsistent presentation. Learners reach for it whenever they need to standardise user input, log messages, or any textual data to a uniform uppercase form.

input_string.upper()

Returns a new string with all cased characters converted to lowercase. Useful for case‑insensitive comparisons or normalizing user input.

text.lower()

Removes leading and trailing whitespace (spaces, tabs, newlines) from a string. Use it when cleaning user input or preparing strings for comparison.

string.strip()

Returns a copy of the string with the first character of each word capitalized and the rest lowercased. Useful for formatting titles or headings.

;.title()

The chunk calls the string method replace to produce a new string where every occurrence of a specified old substring is substituted with a new substring. It addresses the need to modify textual data without manual iteration or concatenation. It is used whenever a developer needs to transform raw text, such as normalising input, masking sensitive information, or updating legacy tokens.

string.replace(old_substring, new_substring)

The split() method breaks a string into a list of substrings using whitespace as the default separator. It is commonly used to tokenize text into words or fields.

; .split()

Pads a string with leading zeros to reach a specified width, returning a new string. Useful for formatting numbers or codes to a fixed length.

string_var.zfill(width)

The pattern checks whether a given string begins with a specified prefix. It addresses the need to quickly identify lines, commands, or data that start with particular characters, avoiding manual slicing or complex regex. It is used whenever code must branch based on the presence of a leading substring.

string.startswith(prefix)

Replaces tab characters in a string with spaces, using a specified tab width (default 8). Useful for normalizing indentation or preparing text for display where tabs should be a fixed width. Typically used when processing text that may contain tabs and you need consistent whitespace handling.

str.expandtabs(width)

The string method casefold() returns a case‑insensitive version of the original text, applying full Unicode case folding. It addresses the pain point of unreliable case‑insensitive comparisons caused by locale‑specific rules or incomplete lowercasing. You reach for it whenever you need to compare or store strings without regard to case across diverse languages.

string.casefold()

Returns a new string with uppercase characters converted to lowercase and lowercase characters converted to uppercase. Non‑alphabetic characters are left unchanged. It is useful when you need to invert the case of a string for display or comparison.

; .swapcase()

Replaces each vowel in a string with a corresponding digit using a translation table built by str.maketrans. This provides a quick way to perform bulk character substitution without explicit loops or regular expressions.

text.translate(str.maketrans(from_chars, to_chars))

The expression uses the ``str.format`` method to inject variable values into a string template. It solves the pain point of manual string concatenation, which is error‑prone and hard to read. You reach for it whenever you need to build a dynamic string from one or more runtime values.

"{placeholder1}{placeholder2}".format(value1, value2)

This pattern formats an integer score into a string that shows a percentage, using the old-style % formatting operator. It is used when a simple, readable label like 'Score: 85%' is needed.

"Score: %d%%" % ;

The f-string formats a numeric price by inserting a dollar sign, adding commas as thousands separators, and limiting the display to two decimal places. It solves the pain point of manually concatenating strings and handling number formatting, which can lead to inconsistent displays. You reach for it whenever you need to present monetary values in a human‑readable form.

f'Total: ${value:,.2f}'

This snippet builds a log message by inserting a user identifier and a formatted date into a template string. It solves the pain point of manually concatenating strings and handling date formatting, which can lead to errors and inconsistent logs. You reach for it whenever you need a clear, locale‑independent representation of a user’s login time.

"{0} logged in at {1:%Y-%m-%d}".format(user_name, login_dt)

It formats an integer error code as a hexadecimal string prefixed with "Error code:" using the old %-formatting operator. This creates a human‑readable error message suitable for logs or console output. It is typically used in legacy Python code when a quick, one‑off formatted string is needed.

'Error code: %x' % error_code

The snippet builds a string by substituting placeholders with values from a dictionary using the ``format_map`` method. It solves the need for dynamic text generation without concatenating strings manually. It is used whenever a program must create personalized messages based on runtime data.

"{greeting}, {name}!".format_map({"greeting": greeting_str, "name": name_str})