Comprehension Patterns

[ ELEMENT  for TARGET in ITERABLE  (for TARGET in ITERABLE | if CONDITION)* ]
{ KEY: VALUE  for ... }          dict comprehension
{ ELEMENT  for ... }             set comprehension
( ELEMENT  for ... )             generator expression (lazy)

result = [f(x, y) for x in xs if p(x) for y in ys if q(x, y)]

# is equivalent to
result = []
for x in xs:
    if p(x):
        for y in ys:
            if q(x, y):
                result.append(f(x, y))

# loop
cleaned = []
for doc in docs:
    cleaned.append(doc.page_content.strip())

# comprehension
cleaned = [doc.page_content.strip() for doc in docs]

messages = [{"role": "user", "content": q} for q in questions]
lengths = [len(tokenizer.encode(t)) for t in texts]
names = [tool["function"]["name"] for tool in tool_schemas]
normalized = [v / norm for v, norm in zip(vectors, norms)]
ids = [f"chunk-{doc_id}-{i}" for i, _ in enumerate(chunks)]

stripped = list(map(str.strip, lines))       # fine, often fastest
stripped = [line.strip() for line in lines]  # also fine
stripped = list(map(lambda s: s.strip(), lines))  # avoid: slower and noisier

# loop
relevant = []
for hit in hits:
    if hit.score >= 0.75:
        relevant.append(hit)

relevant = [hit for hit in hits if hit.score >= 0.75]

user_texts = [m["content"] for m in messages if m["role"] == "user"]
non_empty = [line.rstrip("\n") for line in lines if line.strip()]
python_files = [p for p in root.rglob("*.py") if "venv" not in p.parts]

good = [c for c in chunks if c.score > 0.5 if c.lang == "en"]
good = [c for c in chunks if c.score > 0.5 and c.lang == "en"]

for hit in hits:
    if hit.score < min_score:
        continue
    out.append(hit.text)

out = [hit.text for hit in hits if hit.score >= min_score]
# Note: not (a < b) and (a >= b) differ when a or b is NaN. If scores can be NaN,
# write `if not hit.score < min_score` to keep the loop's exact behaviour.

non_empty = list(filter(None, texts))  # same as [t for t in texts if t]

labels = ["relevant" if s >= threshold else "irrelevant" for s in scores]

# an if/elif/else chain becomes a chained conditional expression
tiers = ["high" if s > 0.8 else "mid" if s > 0.5 else "low" for s in scores]

clipped = [min(s, 1.0) if s > 0 else 0.0 for s in scores if s is not None]

def tier(score: float) -> str:
    if score > 0.9:
        return "excellent"
    if score > 0.75:
        return "good"
    if score > 0.5:
        return "fair"
    return "poor"

tiers = [tier(s) for s in scores]

# [x for x in xs if x > 0 else 0]    -> SyntaxError: else not allowed in the filter position
# [x if x > 0 for x in xs]           -> SyntaxError: conditional expression needs else
[x if x > 0 else 0 for x in xs]      # correct: choose
[x for x in xs if x > 0]             # correct: drop

# flatten a list of lists
flat = [tok for sent in sentences for tok in sent]

# flatten tool calls across responses (None-safe)
calls = [call for resp in responses for call in (resp.tool_calls or [])]

# cartesian product with a filter
pairs = [(q, d) for q in queries for d in docs if d.lang == q.lang]

texts = []
for doc in docs:
    texts.extend(splitter.split_text(doc.page_content))

texts = [t for doc in docs for t in splitter.split_text(doc.page_content)]

[x for x in row for row in matrix]   # NameError (or uses a stale `row`): row is used before defined
[x for row in matrix for x in row]   # correct

matrix = [[0.0] * dim for _ in range(n)]             # n independent rows
bad = [[0.0] * dim] * n                               # n references to ONE row
transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
transpose = [list(col) for col in zip(*matrix)]       # usually clearer
attention_mask = [[1 if tok != pad_id else 0 for tok in seq] for seq in batch]

# compute once, filter on it, keep it
answers = [parsed for raw in outputs if (parsed := try_parse_json(raw)) is not None]

# avoid double tokenization
fits = [(t, n) for t in texts if (n := len(tokenizer.encode(t))) <= max_tokens]

# equivalent without walrus: a nested generator
fits = [(t, n) for t, n in ((t, len(tokenizer.encode(t))) for t in texts) if n <= max_tokens]

total = 0
running = [total := total + n for n in token_counts]

vectors = {rec["id"]: rec["embedding"] for rec in records}
by_name = {tool.name: tool for tool in tools}
config = {k: v for k, v in raw_config.items() if v is not None}
lowercased = {k.lower(): v for k, v in headers.items()}
token_to_id = {tok: i for i, tok in enumerate(vocab)}

id_to_label = {v: k for k, v in label_to_id.items()}   # values must be unique and hashable

# values not unique: invert to lists
from collections import defaultdict
label_to_ids = defaultdict(list)
for doc_id, label in labels.items():
    label_to_ids[label].append(doc_id)

merged = {**defaults, **overrides}          # all versions
merged = defaults | overrides               # 3.9+
params = {k: v for k, v in kwargs.items() if k in ALLOWED_PARAMS}

sources = {c.metadata["source"] for c in chunks}
seen_hashes = {hashlib.sha256(t.encode()).hexdigest() for t in texts}
vocab = {tok for doc in corpus for tok in doc.split()}

unique_in_order = list(dict.fromkeys(items))   # items must be hashable

seen: set[str] = set()
unique = []
for c in chunks:
    key = c.text.strip().lower()
    if key not in seen:
        seen.add(key)
        unique.append(c)

from collections import Counter

counts = {}
for tok in tokens:
    counts[tok] = counts.get(tok, 0) + 1

counts = Counter(tokens)
top = counts.most_common(20)
by_role = Counter(m["role"] for m in messages)

from collections import defaultdict

by_doc = {}
for chunk in chunks:
    by_doc.setdefault(chunk.doc_id, []).append(chunk)

by_doc = defaultdict(list)
for chunk in chunks:
    by_doc[chunk.doc_id].append(chunk)
by_doc = dict(by_doc)   # optional: stop auto-creating keys on lookup

from itertools import groupby
from operator import attrgetter

key = attrgetter("doc_id")
by_doc = {doc_id: list(group) for doc_id, group in groupby(sorted(chunks, key=key), key=key)}

mean_score = {doc_id: sum(c.score for c in cs) / len(cs) for doc_id, cs in by_doc.items()}

numbered = [f"{i}. {q}" for i, q in enumerate(questions, start=1)]
pairs = [(q, a) for q, a in zip(questions, answers, strict=True)]   # strict: 3.10+
records = [{"id": i, **meta} for i, meta in enumerate(metadatas)]
heads = [first for first, *_ in rows]
cosine = [sum(a * b for a, b in zip(u, v)) for u, v in pairs]

async def collect(stream):
    return [chunk.delta async for chunk in stream if chunk.delta]

async def embed_all(batches, client):
    return [await client.embed(b) async for b in batches]   # sequential, one await at a time

import asyncio

async def embed_concurrently(batches, client, limit=8):
    sem = asyncio.Semaphore(limit)

    async def one(batch):
        async with sem:
            return await client.embed(batch)

    return await asyncio.gather(*(one(b) for b in batches))

context_blocks = [
    f"[{i}] {hit.metadata['title']}\n{hit.text}"
    for i, hit in enumerate(hits, start=1)
    if hit.score >= min_score
]

def render_hit(i: int, hit: Hit) -> str:
    return f"[{i}] {hit.metadata['title']}\n{hit.text}"

context_blocks = [render_hit(i, h) for i, h in enumerate(hits, 1) if h.score >= min_score]