When Not to Use a Comprehension

x = "outer"
squares = [x * x for x in range(3)]
print(x)            # "outer": the comprehension's x is separate

for x in range(3):
    pass
print(x)            # 2: a for loop rebinds the enclosing x

names = []
for item in items:
    names.append(item.name)
log.info("last processed: %s", item.id)   # depends on the leaked `item`

names = [item.name for item in items]
last = items[-1] if items else None        # make the dependency explicit

class PromptLibrary:
    PREFIX = "You are a helpful assistant."
    NAMES = ["qa", "summarise"]

    ok = [n.upper() for n in NAMES]                  # fine: NAMES is the outermost iterable
    broken = [f"{PREFIX} {n}" for n in NAMES]        # NameError: PREFIX not visible
    broken2 = [(a, b) for a in NAMES for b in NAMES] # NameError: inner NAMES not visible

PREFIX = "You are a helpful assistant."

class PromptLibrary:
    NAMES = ["qa", "summarise"]
    TEMPLATES = {n: f"{PREFIX} Task: {n}" for n in NAMES}   # PREFIX is a global now

handlers = [lambda: print(name) for name in ["search", "calc"]]
for h in handlers:
    h()          # prints "calc" twice

handlers = [lambda name=name: print(name) for name in ["search", "calc"]]   # bind now
handlers = [functools.partial(print, name) for name in ["search", "calc"]]  # or partial

tools = {spec["name"]: (lambda args, spec=spec: call_tool(spec, args)) for spec in tool_specs}

# smell
results = [log_and_return(parse(r)) for r in raw]

# clearer
results = [parse(r) for r in raw]
log.debug("parsed %d results", len(results))

def safe_parse(raw: str):
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        return None

parsed = [p for raw in outputs if (p := safe_parse(raw)) is not None]

parsed, failures = [], 0
for raw in outputs:
    try:
        parsed.append(json.loads(raw))
    except json.JSONDecodeError:
        failures += 1

# before
rows = [(doc.id, chunk.text, emb) for doc in docs if doc.ok for chunk, emb in zip(doc.chunks, doc.embs) if emb is not None]

# after
rows = []
for doc in docs:
    if not doc.ok:
        continue
    for chunk, emb in zip(doc.chunks, doc.embs):
        if emb is not None:
            rows.append((doc.id, chunk.text, emb))

def valid_rows(docs):
    """(doc_id, text, embedding) for every chunk that has an embedding."""
    for doc in docs:
        if not doc.ok:
            continue
        for chunk, emb in zip(doc.chunks, doc.embs):
            if emb is not None:
                yield doc.id, chunk.text, emb

store.upsert(list(valid_rows(docs)))

ok_docs = [d for d in docs if d.ok]
pairs = [(d, c, e) for d in ok_docs for c, e in zip(d.chunks, d.embs)]
rows = [(d.id, c.text, e) for d, c, e in pairs if e is not None]

# before
batch_ids = [[[vocab[t] for t in sent] for sent in doc] for doc in docs]

# after
def encode_sentence(sent):
    return [vocab[t] for t in sent]

def encode_doc(doc):
    return [encode_sentence(s) for s in doc]

batch_ids = [encode_doc(d) for d in docs]

# f called twice per kept item
out = [f(x) for x in xs if f(x)]

# once
out = [y for x in xs if (y := f(x))]          # 3.8+
out = [y for y in (f(x) for x in xs) if y]   # any version
out = [y for y in map(f, xs) if y]

hits = [h for h in candidates if h.lang == "en" and rerank_score(h) > 0.5]   # rerank only English

# bug: skips elements
for msg in history:
    if msg["role"] == "tool":
        history.remove(msg)

# correct: rebuild (slice assignment keeps the same list object for other references)
history[:] = [m for m in history if m["role"] != "tool"]

- [ ] Is the result used? If not, it must be a for loop.
- [ ] More than 2 fors / 2 ifs / 1 nesting level / 100 chars? Unroll or split.
- [ ] Any calls with side effects inside? Move them to a loop.
- [ ] Does code after it rely on a leaked loop variable?
- [ ] Inside a class body? Check name visibility and walrus.
- [ ] Lambdas or closures created inside? Bind values with defaults or partial.
- [ ] Same expensive call in element and condition? Use walrus or a nested generator.
- [ ] Does the loop body need try/except, break, retries or multiple outputs? Keep the loop.